├── .gitignore ├── DIY-USB-PD-Powered-MCH-Automatic-Reflow-Hotplate-O.pdf ├── PCB_support ├── face-1.ipt ├── face-1.stl ├── face-2.ipt ├── face-2.stl └── test-fit.iam ├── README.md ├── autopush.sh ├── firmware ├── README.txt ├── reflow-v6 │ ├── desolder.ino │ ├── reflow-v6.ino │ ├── reflow.ino │ ├── signals.ino │ └── utils.ino └── reflow │ ├── reflow.ino │ ├── signals.ino │ └── utils.ino ├── model ├── base.ipt ├── base.stl ├── wood_supp.stl ├── wood_suppv2.dwg ├── wood_suppv2.dxf └── wood_suppv3.ipt ├── package ├── package-zh.png ├── package-zh.psd ├── package.png └── package.psd ├── pcb ├── v4.1 │ ├── BOM v4.1 modified.csv │ ├── Gerber_PCB_Reflow Hotplate v4.1.zip │ ├── PCB_PCB_Reflow Hotplate v3_2024-01-06.json │ ├── PCB_PCB_Reflow Hotplate v4_2024-01-06.json │ └── PickAndPlace_PCB_Reflow Hotplate v4_2023-10-31.csv ├── v6 │ ├── Gerber_Reflow-Hotplate_PCB_Reflow-Hotplate-v6_2024-05-24r2.zip │ └── PCB_PCB_Reflow-Hotplate-v6_2024-05-24.json └── v7 │ ├── Gerber_Reflow-Hotplate_PCB_Reflow-Hotplate-v7.1_2024-06-12r2.zip │ └── PCB_PCB_Reflow-Hotplate-v7.1_2024-06-12.json ├── photo ├── 0.jpg ├── 1.jpg ├── 2.jpg ├── 3.jpg ├── 4.jpg ├── 5.jpg └── 6.jpg └── schematic ├── CH552G.png ├── IP2721.png └── Reflow curve.png /.gitignore: -------------------------------------------------------------------------------- 1 | # Prerequisites 2 | *.d 3 | 4 | # Compiled Object files 5 | *.slo 6 | *.lo 7 | *.o 8 | *.obj 9 | 10 | # Precompiled Headers 11 | *.gch 12 | *.pch 13 | 14 | # Compiled Dynamic libraries 15 | *.so 16 | *.dylib 17 | *.dll 18 | 19 | # Fortran module files 20 | *.mod 21 | *.smod 22 | 23 | # Compiled Static libraries 24 | *.lai 25 | *.la 26 | *.a 27 | *.lib 28 | 29 | # Executables 30 | *.exe 31 | *.out 32 | *.app 33 | -------------------------------------------------------------------------------- /DIY-USB-PD-Powered-MCH-Automatic-Reflow-Hotplate-O.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tobychui/MCH-PD-Automatic-Reflow-Hotplate/d20e28c2106b5c26850c6e21c75fcf41419833f8/DIY-USB-PD-Powered-MCH-Automatic-Reflow-Hotplate-O.pdf -------------------------------------------------------------------------------- /PCB_support/face-1.ipt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tobychui/MCH-PD-Automatic-Reflow-Hotplate/d20e28c2106b5c26850c6e21c75fcf41419833f8/PCB_support/face-1.ipt -------------------------------------------------------------------------------- /PCB_support/face-1.stl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tobychui/MCH-PD-Automatic-Reflow-Hotplate/d20e28c2106b5c26850c6e21c75fcf41419833f8/PCB_support/face-1.stl -------------------------------------------------------------------------------- /PCB_support/face-2.ipt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tobychui/MCH-PD-Automatic-Reflow-Hotplate/d20e28c2106b5c26850c6e21c75fcf41419833f8/PCB_support/face-2.ipt -------------------------------------------------------------------------------- /PCB_support/face-2.stl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tobychui/MCH-PD-Automatic-Reflow-Hotplate/d20e28c2106b5c26850c6e21c75fcf41419833f8/PCB_support/face-2.stl -------------------------------------------------------------------------------- /PCB_support/test-fit.iam: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tobychui/MCH-PD-Automatic-Reflow-Hotplate/d20e28c2106b5c26850c6e21c75fcf41419833f8/PCB_support/test-fit.iam -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | ![](photo/0.jpg) 2 | 3 | # MCH PD Powered Reflow Hotplate 4 | 5 | A palm sized MCH (Metal Ceramic Heater) based reflow hotplate powered by USB-PD 6 | 7 | This is a DIY, low cost PD powered reflow hotplate that uses metal ceramic heater (MCH) instead of PCB hot plate for heating. It features a USB type C input port that can be powered by a 60W (65W) PD power supply at 20V 3A. This hotplate can automatically reflow mid-temperature range solder paste like Sn63Pb37. What you need is press and hold the START button for 5 seconds and wait for the reflow process to finish. 8 | 9 | ### Features 10 | 11 | - USB type C PD Powered (no special power adapter or dangerous AC power required) 12 | - Budget & High quality heating element (instead of PCB hotplate) 13 | - Open Source 14 | - Fully automatic, just hold and press "START" and wait for the reflow to complete 15 | 16 | ## Ready to Use Hotplate 17 | You can get a prototype from my [Tindie store](https://www.tindie.com/products/tobychui/tobys-automatic-mch-pd-reflow-hotplate/) 18 | 19 | ## Quick Start 20 | 21 | 1. Power up your reflow hotplate with 60W or above PD charger (PD power bank works as well) 22 | 2. After the MCU boots up, the yellow LED should blink slowly, indicating it is ready 23 | 3. Place your PCB to be reflow on top of the white MCH module 24 | 4. Press and hold the START touch button until the yellow LED start fast blinking 25 | 5. Wait until the hotplate automatically complete the reflow process. After the reflow is done, you will see the red light blinking slowly. 26 | 6. Carefully remove the completed PCB away from the MCH module. Press STOP to reset the hotplate and it is ready for the next reflow cycle. 27 | 28 | ### Reflow Stages 29 | 30 | | Stages | LED Status | Meaning | 31 | | ------ | -------------------- | ---------------------------------------- | 32 | | 1 | Yellow Slow Blinking | System Ready | 33 | | 2 | Yellow Fast Blinking | Automatic Reflow starting in 5 seconds | 34 | | 3 | Yellow ON | Heating to soaking temperature (<150 °C) | 35 | | 4 | Red Fast Blinking | Soaking (150 - 180 °C) | 36 | | 5 | Red ON | Reflowing (220 °C) | 37 | | 6 | Red Slow Blinking | Reflow completed. Remove PCB now | 38 | 39 | After stage 6 is completed and you have removed the PCB from the hotplate, press STOP once to reset the stage to 1. You can also press STOP anytime you think it is suitable, including early stopping if your PCB is small and do not require that much temperature in the reflow stage. 40 | 41 | ## Desolder Mode 42 | This mode was added since the v6 revision of the hotplate. **Older version of the hotplates are not compatible with this new firmware.** 43 | 44 | In case you want to desolder something that you misplaced or recover components from damaged PCB, you can press and hold "START" + "STOP" for 5 seconds until the yellow LED start fast blinking. 45 | Then the reflow hotplate will enter desolder mode and keep at reflow temperature for 5 minutes. 46 | 47 | ## Specifications 48 | 49 | | properties | Value | 50 | | ----------------------------------- | ------------------------------------------------------------ | 51 | | Controller | CH552G (Arduino Programmable) | 52 | | LEDs | Yellow(Preheat / Soaking), Red(Reflow) | 53 | | Dimension (Without Base, W x L x H) | 54mm * 102mm * 30mm | 54 | | Dimension (Assembled, W x L x H) | 54mm * 102mm * 48mm | 55 | | Heat-plate Size | 40mm * 40mm (± 1mm) | 56 | | Require External Programmer | No (USB programming pins exposed as 2.54 pads) | 57 | | Power Input | USB type-C PD 20V 3A (60W / 65W PD power supply recommended) | 58 | | Power Consumption | 30 - 50W (Depends on reflow stage) | 59 | | USB Connector | USB type C | 60 | | Solder Paste | Sn63Pb37 (Reflow profile editable in source code w/ Arduino IDE) | 61 | 62 | ## Gallery 63 | ### v2 Hotplates (Original) 64 | ![](photo/1.jpg) 65 | 66 | ![](photo/2.jpg) 67 | 68 | ![](photo/3.jpg) 69 | 70 | ![](photo/4.jpg) 71 | 72 | ![](photo/5.jpg) 73 | 74 | ![](photo/6.jpg) 75 | 76 | ### v6/7 Hotplates 77 | ![title](https://github.com/tobychui/MCH-PD-Automatic-Reflow-Hotplate/assets/24617523/8524ffd2-5e0f-4313-bb5c-98a8c52c2d89) 78 | 79 | See more over [here](https://github.com/tobychui/MCH-PD-Automatic-Reflow-Hotplate/wiki/Introduction-to-the-v6-Hotplate!) 80 | 81 | ## Programming 82 | 83 | ### Programming Interface 84 | 85 | 1. The PCB contains a 2.54x4 pins labeled PROG (USB) with 5V, D+, D- and GND. This is a standard USB 2.0 connector as CH552G has build in USB hosts mode that do not require a USB to UART converter chip. Solder a USB male header at this location following the pins label written on the silkscreen. 86 | 87 | 2. There are another 2.54 x 3 pins also labeled PROG on the left 2 pins of the 3 pins. It is for forcing the CH552G into USB programming mode. If you want to re-program the reflow hotplate, bridge the two left most pins (the two pins closer to the LED) of the 2.54x3 and connect the USB pins to your computer. Otherwise, you can bridge the right-2 pins or leave all 3 pins unconnected. 88 | 89 | ### Flashing (Downloading) New Firmware 90 | 91 | The timing for downloading the firmware are critical to the success of firmware download. Please follow EXACTLY on how to flash the firmware with the steps below. 92 | 93 | #### Serial Mode 94 | 95 | 1. After you have finish changing the code in the firmware, select "16Mhz (internal, 3.3V or 5V)" in the "Clock Source" menu. For upload method, select "Serial" 96 | 2. Insert the hotplate's USB port into your computer. A new COM port should pops up. Select that newly pop-up COM port as download target 97 | 3. Click the Download button in your Arduino IDE 98 | 99 | #### USB Mode 100 | 101 | In case the Serial mode is not working due to some driver conflict or Windows bug, you can optionally choose USB upload mode 102 | 103 | 1. After you have finish changing the code in the firmware, select "16Mhz (internal, 3.3V or 5V)" in the "Clock Source" menu. For upload method, select "USB" 104 | 2. Click the Download button in your Arduino IDE 105 | 3. At the same time of doing step 2, bridge the left-two PROG pins from the 2.54 x 3 header, and quickly insert the USB port into your computer's USB port (timing is important) 106 | 4. Just before the Arduino IDE starts to upload, un-bridge the left-two PROG pins from the 2.54 x 3 header. If you keep them bridged, the Arduino IDE will freeze during upload and after a few seconds report upload failed due to timeout. 107 | 5. If timing is correct, you will see the Arduino debug console says upload completed 108 | 6. If you un-bridge it too early, you will see a new COM device pops up. You will need to unplug the device, short the left-two PROG pins again and repeat step 3 - 4. 109 | 110 | 111 | 112 | ### Notes 113 | 114 | - If you encounter issues with yellow LED not light up when powered up / unstable touch buttons / lower than expected peak reflow temperature, please make sure you are using a high quality PD power supply and cables that is designed for 60W or above. 115 | 116 | - The reflow temperature is intentionally set higher than the expected temperature of 230 degree celcius to make up for the lose in heat to the surrounding. You can perform early-stopping if the reflow is completed but the hotplate is still heating up. 117 | 118 | ## License 119 | 120 | CC BY-NC-SA 121 | -------------------------------------------------------------------------------- /autopush.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | echo Enter commit notes: 3 | read commitmsg 4 | git pull 5 | git add * 6 | git commit -m "$commitmsg" 7 | git push -------------------------------------------------------------------------------- /firmware/README.txt: -------------------------------------------------------------------------------- 1 | For PCB versions before 6 (v1 - v5), use the reflow.ino firmware. 2 | For PCB versions 6 or above, use the reflow-v6 firmware. -------------------------------------------------------------------------------- /firmware/reflow-v6/desolder.ino: -------------------------------------------------------------------------------- 1 | /* desolder.ino handles desoldering (aka just a basic heated plate) procedures */ 2 | 3 | void handleDesolderProcedures() { 4 | bool tempReached = updateHeaterPowerState(); //This take around 100ms 5 | if (reflowStages == 10 && tempReached) { 6 | //Temperature reached. Stop red blinking and light up red light 7 | fastblinkRed = false; 8 | digitalWrite(LED_REFLOW, HIGH); 9 | desolderCountdown = MAX_CONTINUE_OPR_TIME; //Start counting down max operation time 10 | reflowStages = 11; //Move to consistent heating mode 11 | } 12 | 13 | if (desolderCountdown == 0) { 14 | enterStandbyMode(); 15 | desolderCountdown = 0; //Prevent underflow 16 | } 17 | desolderCountdown--; 18 | } -------------------------------------------------------------------------------- /firmware/reflow-v6/reflow-v6.ino: -------------------------------------------------------------------------------- 1 | /* 2 | 60W PD Powered Automatic Reflow Hoteplate 3 | Author: tobychui 4 | 5 | Firmware version for v6 or above PCB 6 | 7 | Notes: 8 | - Temperature sensing is done using 1k 1% resistor and a 100k Thermistor 9 | You might need to change the code if you are using other values 10 | - If you are using the type-C 6p version of the reflow PCB, and after 11 | pluggin in the type C cable no led lights up, try flip the type C 12 | cable upside down 13 | 14 | Button Mappings (Active Low, aka not pressing = HIGH) 15 | Start Btn: P1.4 16 | Stop Btn: P1.7 17 | 18 | Download Settings 19 | CH552 20 | 16Mhz (internal, 3.3V or 5V) 21 | */ 22 | #include 23 | 24 | /* Hardware Definations */ 25 | #define TEMP_PIN 11 //P1.1 26 | #define HEATER_PIN 34 //P3.4 27 | #define LED_PREHEAT 15 //P1.5 28 | #define LED_REFLOW 16 //P1.6 29 | #define START_BTN 14 //P1.4 30 | #define STOP_BTN 17 //P1.7 31 | 32 | /* Software Definations */ 33 | //Timing settings. Each cycle is approximately 100ms 34 | #define HOLDSTART_TIME 30 //START Button hold down time in cycles 35 | #define HOLDSTOP_TIME 10 //STOP Button hold down time in cycles 36 | #define SOAKING_TIME 600 //SOAKING temperature upkeep time in cycles 37 | #define MAX_CONTINUE_OPR_TIME 3000 //MAX_CONTINUE_OPR automatic shutdown desolder heatbed if continue operate for ~5 minutes for safty reasons 38 | /* 39 | Temperature Settings 40 | 41 | The ADC value can be calculated using the following line equation 42 | t=-0.7x+250 43 | 44 | where X is ADC reading and t is target temp in degree C 45 | 46 | Note that different setup (e.g. ref resistor value / NTC resistor value) might have different equations 47 | You can experiment with yours and get a few data point to plot your own line 48 | */ 49 | #define COOLDOWN_TEMP_ADC 255 //Room temperature 50 | //Preheat temp & power 51 | #define PREHEAT_START_ADC 143 //150 degree C 52 | #define PREHEAT_TEMP_ADC 122 //160 degree C 53 | #define PREHEAT_PWR_PWM 155 //60% power output 54 | //Reflow temp & power 55 | #define REFLOW_TEMP_ADC 58 //220 degree C 56 | #define REFLOW_PWR_PWM 255 //100% power output 57 | //Overheat cutoff temp 58 | #define CUTOFF_TEMP_ADC 53 //250 degree C 59 | 60 | /* Function Prototypes */ 61 | bool updateHeaterPowerState(); 62 | void updateKeyStates(); 63 | void handleLEDBlinking(); 64 | void handleReflowProcedures(); 65 | void handleDesolderProcedures(); 66 | void enterStandbyMode(); 67 | int readTemp(); 68 | 69 | 70 | /* Runtime Variables */ 71 | bool reflowing = false; //Reflow has started 72 | bool reflowComplete = false; //Indicate if the stopping is done because of reflow complete 73 | bool startPressed = false; //Start button is pressed down 74 | bool stopPressed = false; //Stop button is pressed down 75 | 76 | /* 77 | Reflow Stages define what is the next state the hotplate should reach 78 | 0: Standby 79 | 1: Preheating 80 | 2: Preheat Holding / Soaking 81 | 3: Reflowing 82 | 4: Cooling down 83 | 84 | 10: Preheating to reflow temp for desoldering 85 | 11: Desolder Mode (Keep at REFLOW_TEMP_ADC) 86 | */ 87 | int reflowStages = 0; 88 | int startCountdown = HOLDSTART_TIME; //Hold for HOLDSTART_TIME to start to prevent accidental touches 89 | int stopcountdown = HOLDSTOP_TIME; //Hold for HOLDSTOP_TIME to stop reflowing 90 | int cycleCounter = 0; //Record cycle time up to 10 seconds 91 | int soakingCountdown = SOAKING_TIME; 92 | int desolderCountdown = MAX_CONTINUE_OPR_TIME; //Prevent overheat 93 | 94 | //Blink state controls 95 | bool blinkState = false; //If blinking this will be switching between true and false 96 | bool blinkYellow = true; //Slow blink yellow if enabled (Standby). Do not enable both yellow and red at the same time 97 | bool blinkRed = false; //Slow blink red if enable (End of Reflow). Do not enable both yellow and red at the same time 98 | bool fastBlinkState = false; 99 | bool fastblinkRed = false; 100 | 101 | 102 | //Real-time temperature control targets 103 | int targetTempADC = 255; //Target ADC reading to reach, 255 = room temperature 104 | int targetPwrPWM = 0; //Target PWM cycle for heater, 255 = full power, 0 = off 105 | int offset = 0; //Allow +-offset for the ADC reading before reheating / cooling 106 | 107 | void setup() { 108 | //Set button pins to input 109 | pinMode(START_BTN, INPUT); 110 | pinMode(STOP_BTN, INPUT); 111 | 112 | //Set LED pins to output 113 | pinMode(LED_PREHEAT, OUTPUT); 114 | pinMode(LED_REFLOW, OUTPUT); 115 | digitalWrite(LED_PREHEAT, LOW); 116 | digitalWrite(LED_REFLOW, LOW); 117 | 118 | //Set temp sense pin to input 119 | pinMode(TEMP_PIN, INPUT); 120 | 121 | //Set mosfet control pins to output and disable it 122 | pinMode(HEATER_PIN, OUTPUT); 123 | digitalWrite(HEATER_PIN, LOW); 124 | 125 | USBSerial_println("Reflow Hotplate Ready!"); 126 | } 127 | 128 | 129 | void loop() { 130 | /* State Check */ 131 | updateKeyStates(); 132 | 133 | /* Main reflowing logics */ 134 | //Add delay to the end of each conditions so each loop cycle is approximate 100ms 135 | if (reflowing && reflowStages < 10) { 136 | //Automatic Reflow 137 | handleReflowProcedures(); 138 | } else if (reflowing && reflowStages >= 10) { 139 | //Desolder hotplate 140 | handleDesolderProcedures(); 141 | } else { 142 | /* Standby Mode */ 143 | digitalWrite(HEATER_PIN, LOW); 144 | blinkYellow = true; 145 | delay(100); //adjust this if needed to make sure reflow cycles use the same time as standby cycles 146 | } 147 | 148 | /* Blink Signal Handlers */ 149 | handleLEDBlinking(); 150 | 151 | /* 152 | Cycle Counter 153 | Counter are limited to 600 to prevent overflow. 154 | */ 155 | 156 | cycleCounter++; 157 | if (cycleCounter > 600) { 158 | cycleCounter = 0; 159 | } 160 | } 161 | -------------------------------------------------------------------------------- /firmware/reflow-v6/reflow.ino: -------------------------------------------------------------------------------- 1 | /* reflow.ino handles reflow procedures */ 2 | 3 | void handleReflowProcedures() { 4 | /* Currently is in reflow stage */ 5 | bool tempReached = updateHeaterPowerState(); //This action takes 100ms 6 | if (tempReached) { 7 | //This stage temperature reached. Move to next stage 8 | if (reflowStages == 1) { 9 | //Preheat stage completed. Enter soaking stage 10 | USBSerial_println("Preheat temperature reached. Soaking started"); 11 | targetTempADC = PREHEAT_TEMP_ADC; //Set temperature to soaking end temp 12 | reflowStages = 2; //Set reflow stage to soaking 13 | soakingCountdown = SOAKING_TIME; 14 | fastblinkRed = true; 15 | } else if (reflowStages == 3) { 16 | //Reflowing target temperature reached. Start cooldown and shut down heater 17 | USBSerial_println("Reflow completed. Cooling down"); 18 | reflowStages = 4; 19 | blinkYellow = false; 20 | blinkRed = true; 21 | targetTempADC = COOLDOWN_TEMP_ADC; 22 | targetPwrPWM = 0; 23 | 24 | //Reflow ended. Wait until stop being press to exit this state 25 | } 26 | } 27 | 28 | if (reflowStages == 2) { 29 | //Wait for the soaking to complete and enter reflow stage 30 | soakingCountdown--; 31 | if (soakingCountdown <= 0) { 32 | //Soaking completed. Enter reflow stage 33 | USBSerial_println("Soaking time ended. Reflow started"); 34 | 35 | //Set Reflow LED to high 36 | fastblinkRed = false; 37 | digitalWrite(LED_REFLOW, HIGH); 38 | 39 | //Set to reflow temperature 40 | targetTempADC = REFLOW_TEMP_ADC; //Set the target temp to reflow 41 | targetPwrPWM = REFLOW_PWR_PWM; //Set power rating to reflow 42 | 43 | //Update the reflow stage to 3 44 | reflowStages = 3; 45 | } else if (soakingCountdown % 100 == 0) { 46 | USBSerial_print("Soaking cycles left: "); 47 | USBSerial_println(soakingCountdown); 48 | } 49 | } 50 | 51 | delay(1); 52 | } -------------------------------------------------------------------------------- /firmware/reflow-v6/signals.ino: -------------------------------------------------------------------------------- 1 | //When the reflow starts, preheat leds will fast blink 2 | //to indicate auto reflow will start in 5 seconds 3 | void playStartingLEDBlinks(){ 4 | digitalWrite(LED_PREHEAT, LOW); 5 | for(int i = 0; i < 10; i++){ 6 | digitalWrite(LED_PREHEAT, HIGH); 7 | delay(200); 8 | digitalWrite(LED_PREHEAT, LOW); 9 | delay(200); 10 | } 11 | } 12 | 13 | //Update the button press state to global variable 14 | void updateButtonPressState(){ 15 | int x = digitalRead(START_BTN); 16 | startPressed = (x == LOW); 17 | x = digitalRead(STOP_BTN); 18 | stopPressed = (x == LOW); 19 | } 20 | 21 | //Handle LED states in this cycle 22 | void handleLEDBlinking(){ 23 | //FastBlink handler, execute every 500ms 24 | if (cycleCounter % 5 == 0 && fastblinkRed) { 25 | digitalWrite(LED_PREHEAT, LOW); 26 | if (fastBlinkState) { 27 | digitalWrite(LED_REFLOW, HIGH); 28 | } else { 29 | digitalWrite(LED_REFLOW, LOW); 30 | } 31 | fastBlinkState = !fastBlinkState; 32 | } 33 | 34 | //Blink handler, execute every 2 seconds 35 | if (cycleCounter % 20 == 0) { 36 | if (blinkYellow) { 37 | if (blinkState) { 38 | digitalWrite(LED_PREHEAT, HIGH); 39 | } else { 40 | digitalWrite(LED_PREHEAT, LOW); 41 | } 42 | } else if (blinkRed) { 43 | if (blinkState) { 44 | digitalWrite(LED_REFLOW, HIGH); 45 | } else { 46 | digitalWrite(LED_REFLOW, LOW); 47 | } 48 | } 49 | blinkState = !blinkState; 50 | } 51 | } -------------------------------------------------------------------------------- /firmware/reflow-v6/utils.ino: -------------------------------------------------------------------------------- 1 | //Read Temp read the current temperature of the hotplate 2 | /* 3 | * Read Current temperature from ADC 4 | * The ADC is reading from a voltage divider 5 | * 5V --- 1k Ohm --- (ADC) --- 100k NTC --- GND 6 | * 7 | * ADC Reading / Temperature (degree C) 8 | * 250 / 25 9 | * 225 / 100 10 | * 155 / 160 (Preheat Temp) 11 | * 123 / 220 (Reflow Temp) 12 | * 100 / 240 (Hard cutoff Temp) 13 | * 14 | * Each reading takes around 100ms 15 | */ 16 | int readTemp() { 17 | int numReadings = 10; // Number of readings to average 18 | int totalSensorValue = 0; 19 | 20 | for (int i = 0; i < numReadings; ++i) { 21 | totalSensorValue += analogRead(TEMP_PIN); 22 | delay(10); // Optional: add a small delay between readings if needed 23 | } 24 | 25 | // Calculate the average sensor value 26 | int averageSensorValue = totalSensorValue / numReadings; 27 | 28 | return averageSensorValue; 29 | } 30 | 31 | //enterStandbyMode move the hotplate state to standby and cutoff power to hotplate 32 | void enterStandbyMode() { 33 | reflowing = false; 34 | USBSerial_println("Reflow Stopped"); 35 | //Set target temperature to room temp and shut down heater 36 | targetTempADC = COOLDOWN_TEMP_ADC; 37 | targetPwrPWM = 0; 38 | 39 | //Set yellow LED to slow blinkRed 40 | digitalWrite(LED_REFLOW, LOW); 41 | digitalWrite(LED_PREHEAT, LOW); 42 | blinkYellow = true; 43 | blinkRed = false; 44 | fastblinkRed = false; 45 | 46 | //Set reflow stage to standby 47 | reflowStages = 0; 48 | } 49 | 50 | //Update heater power state base on temp reading 51 | //The hotter the plate, the smaller the ADC reading 52 | //Return true when the temperature is within target range 53 | bool updateHeaterPowerState() { 54 | int currentADC = readTemp(); 55 | if (currentADC <= CUTOFF_TEMP_ADC) { 56 | digitalWrite(HEATER_PIN, LOW); 57 | USBSerial_println("!!! OVERHEAT !!!"); 58 | digitalWrite(LED_PREHEAT, HIGH); 59 | digitalWrite(LED_REFLOW, HIGH); 60 | return false; 61 | } 62 | if (currentADC > targetTempADC + offset) { 63 | //Temperature too low. Turn on the heater 64 | analogWrite(HEATER_PIN, targetPwrPWM); 65 | //USBSerial_print("+ "); 66 | //USBSerial_println(currentADC); 67 | return false; 68 | } else if (currentADC < targetTempADC - offset) { 69 | //Temperature too high. Turn off the heater 70 | analogWrite(HEATER_PIN, 0); 71 | //USBSerial_print("- "); 72 | //USBSerial_println(currentADC); 73 | return false; 74 | } else { 75 | //Within range. Keep the current state 76 | return true; 77 | } 78 | } 79 | 80 | //Update Key States handle touch button events listening and global state update 81 | void updateKeyStates() { 82 | //Read the current buttons state 83 | updateButtonPressState(); 84 | 85 | //Start button, require hold down for 3 seconds to start 86 | if (startPressed) { 87 | startCountdown--; 88 | if (startCountdown <= 0 && !reflowing) { 89 | if (stopPressed) { 90 | //Holding two buttons together. Enter desolder mode 91 | USBSerial_println("!!! Desolder Mode Started !!!"); 92 | reflowing = true; 93 | startCountdown = 0; //Prevent underflow counter 94 | playStartingLEDBlinks(); //Play fast blink start warning 95 | targetTempADC = REFLOW_TEMP_ADC; //Set the target temp to reflow target temp 96 | targetPwrPWM = REFLOW_PWR_PWM; //Set power rating to 100% 97 | reflowStages = 10; //Set the reflow stage to desolder 98 | 99 | //Set red LED to blink fast 100 | blinkYellow = false; 101 | blinkRed = false; 102 | fastblinkRed = true; 103 | } else { 104 | //Holding start button only. Enter automatic reflow mode 105 | /* START REFLOW PROCESS - PREHEAT */ 106 | USBSerial_println("!!! Reflow Started !!!"); 107 | reflowing = true; 108 | startCountdown = 0; //Prevent it from going underflow 109 | playStartingLEDBlinks(); //Play fast blink start warning 110 | targetTempADC = PREHEAT_START_ADC; //Set the target temp to preheat starting temp 111 | targetPwrPWM = PREHEAT_PWR_PWM; //Set power rating to preheat 112 | reflowStages = 1; //Set the reflow stage to preheating 113 | 114 | //Set the blinking LED status to off 115 | blinkYellow = false; 116 | blinkRed = false; 117 | fastblinkRed = false; 118 | digitalWrite(LED_PREHEAT, HIGH); //Light up the preheat LED 119 | } 120 | return; 121 | } 122 | } else { 123 | //Press released 124 | startCountdown = HOLDSTART_TIME; 125 | } 126 | 127 | //Stop button, stop immediately 128 | if (stopPressed) { 129 | enterStandbyMode(); 130 | } 131 | } 132 | -------------------------------------------------------------------------------- /firmware/reflow/reflow.ino: -------------------------------------------------------------------------------- 1 | /* 2 | 60W PD Powered Automatic Reflow Hoteplate 3 | Author: tobychui 4 | 5 | Notes: 6 | Temperature sensing is done using 1k 1% resistor and a 10k Thermistor 7 | You might need to change the code if you are using other values 8 | 9 | Touch Button Mappings 10 | Start Btn: P1.4 11 | Stop Btn: P1.7 12 | 13 | Download Settings 14 | CH552 15 | 16Mhz (internal, 3.3V or 5V) 16 | */ 17 | #include 18 | #include 19 | 20 | #define TEMP_PIN 11 //P1.1 21 | #define HEATER_PIN 34 //P3.4 22 | #define LED_PREHEAT 15 //P1.5 23 | #define LED_REFLOW 16 //P1.6 24 | 25 | //Timing settings. Each cycle is approximately 100ms 26 | #define HOLDSTART_TIME 30 //START Button hold down time in cycles 27 | #define HOLDSTOP_TIME 10 //STOP Button hold down time in cycles 28 | #define SOAKING_TIME 600 //SOAKING temperature upkeep time in cycles 29 | 30 | /* 31 | * Temperature Settings 32 | * 33 | * The ADC value can be calculated using the following line equation 34 | * t=-0.7x+250 35 | * 36 | * where X is ADC reading and t is target temp in degree C 37 | * 38 | * Note that different setup (e.g. ref resistor value / NTC resistor value) might have different equations 39 | * You can experiment with yours and get a few data point to plot your own line 40 | */ 41 | #define COOLDOWN_TEMP_ADC 255 //Room temperature 42 | //Preheat temp & power 43 | #define PREHEAT_START_ADC 143 //150 degree C 44 | #define PREHEAT_TEMP_ADC 122 //160 degree C 45 | #define PREHEAT_PWR_PWM 155 //60% power output 46 | //Reflow temp & power 47 | #define REFLOW_TEMP_ADC 58 //220 degree C 48 | #define REFLOW_PWR_PWM 255 //100% power output 49 | //Overheat cutoff temp 50 | #define CUTOFF_TEMP_ADC 53 //230 degree C 51 | 52 | //Func def 53 | bool updateHeaterPowerState(); 54 | void updateKeyStates(); 55 | int readTemp(); 56 | 57 | 58 | //Runtimes 59 | bool reflowing = false; //Reflow has started 60 | bool reflowComplete = false; //Indicate if the stopping is done because of reflow complete 61 | /* 62 | Reflow Stages define what is the next state the hotplate should reach 63 | 0: Standby 64 | 1: Preheating 65 | 2: Preheat Holding / Soaking 66 | 3: Reflowing 67 | 4: Cooling down 68 | */ 69 | int reflowStages = 0; 70 | int startCountdown = HOLDSTART_TIME; //Hold for HOLDSTART_TIME to start to prevent accidental touches 71 | int stopcountdown = HOLDSTOP_TIME; //Hold for HOLDSTOP_TIME to stop reflowing 72 | int cycleCounter = 0; //Record cycle time up to 10 seconds 73 | int soakingCountdown = SOAKING_TIME; 74 | 75 | //Blink state controls 76 | bool blinkState = false; //If blinking this will be switching between true and false 77 | bool blinkYellow = true; //Slow blink yellow if enabled (Standby). Do not enable both yellow and red at the same time 78 | bool blinkRed = false; //Slow blink red if enable (End of Reflow). Do not enable both yellow and red at the same time 79 | bool fastBlinkState = false; 80 | bool fastblinkRed = false; 81 | 82 | 83 | //Real-time temperature control targets 84 | int targetTempADC = 255; //Target ADC reading to reach, 255 = room temperature 85 | int targetPwrPWM = 0; //Target PWM cycle for heater, 255 = full power, 0 = off 86 | int offset = 0; //Allow +-offset for the ADC reading before reheating / cooling 87 | 88 | void setup() { 89 | //Enable the touch buttons 90 | //Enable all 6 channels:TIN2(P1.4),TIN5(P1.7) 91 | TouchKey_begin((1 << 2) | (1 << 5)); 92 | 93 | //refer to AN3891 MPR121 Baseline System for more details 94 | TouchKey_SetMaxHalfDelta(164); // increase if sensor value are more noisy 95 | TouchKey_SetNoiseHalfDelta(8); // If baseline need to adjust at higher rate, increase this value 96 | TouchKey_SetNoiseCountLimit(10); // If baseline need to adjust faster, increase this value 97 | TouchKey_SetFilterDelayLimit(5); // make overall adjustment slower 98 | TouchKey_SetTouchThreshold(220); // Bigger touch pad can use a bigger value 99 | TouchKey_SetReleaseThreshold(150); // Smaller than touch threshold 100 | 101 | //Set LED pins to output 102 | pinMode(LED_PREHEAT, OUTPUT); 103 | pinMode(LED_REFLOW, OUTPUT); 104 | digitalWrite(LED_PREHEAT, LOW); 105 | digitalWrite(LED_REFLOW, LOW); 106 | 107 | //Set temp sense pin to input 108 | pinMode(TEMP_PIN, INPUT); 109 | 110 | //Set mosfet control pins to output and disable it 111 | pinMode(HEATER_PIN, OUTPUT); 112 | digitalWrite(HEATER_PIN, LOW); 113 | } 114 | 115 | 116 | void loop() { 117 | //Check key status 118 | updateKeyStates(); 119 | 120 | //Main reflowing logics 121 | //Add delay to the end of each conditions so each loop cycle is approximate 100ms 122 | if (reflowing) { 123 | bool tempReached = updateHeaterPowerState(); //This action takes 100ms 124 | if (tempReached) { 125 | //This stage temperature reached. Move to next stage 126 | if (reflowStages == 1) { 127 | //Preheat stage completed. Enter soaking stage 128 | USBSerial_println("Preheat temperature reached. Soaking started"); 129 | targetTempADC = PREHEAT_TEMP_ADC; //Set temperature to soaking end temp 130 | reflowStages = 2; //Set reflow stage to soaking 131 | soakingCountdown = SOAKING_TIME; 132 | fastblinkRed = true; 133 | } else if (reflowStages == 3) { 134 | //Reflowing target temperature reached. Start cooldown and shut down heater 135 | USBSerial_println("Reflow completed. Cooling down"); 136 | reflowStages = 4; 137 | blinkYellow = false; 138 | blinkRed = true; 139 | targetTempADC = COOLDOWN_TEMP_ADC; 140 | targetPwrPWM = 0; 141 | 142 | //Reflow ended. Wait until stop being press to exit this state 143 | } 144 | } 145 | 146 | if (reflowStages == 2) { 147 | //Wait for the soaking to complete and enter reflow stage 148 | soakingCountdown--; 149 | if (soakingCountdown <= 0) { 150 | //Soaking completed. Enter reflow stage 151 | USBSerial_println("Soaking time ended. Reflow started"); 152 | 153 | //Set Reflow LED to high 154 | fastblinkRed = false; 155 | digitalWrite(LED_REFLOW, HIGH); 156 | 157 | //Set to reflow temperature 158 | targetTempADC = REFLOW_TEMP_ADC; //Set the target temp to reflow 159 | targetPwrPWM = REFLOW_PWR_PWM; //Set power rating to reflow 160 | 161 | //Update the reflow stage to 3 162 | reflowStages = 3; 163 | } else if (soakingCountdown % 100 == 0) { 164 | USBSerial_print("Soaking cycles left: "); 165 | USBSerial_println(soakingCountdown); 166 | } 167 | } 168 | 169 | 170 | delay(1); 171 | } else { 172 | //Standby mode 173 | digitalWrite(HEATER_PIN, LOW); 174 | blinkYellow = true; 175 | delay(100); 176 | } 177 | 178 | //FastBlink handler, execute every 500ms 179 | if (cycleCounter % 5 == 0 && fastblinkRed) { 180 | digitalWrite(LED_PREHEAT, LOW); 181 | if (fastBlinkState) { 182 | digitalWrite(LED_REFLOW, HIGH); 183 | } else { 184 | digitalWrite(LED_REFLOW, LOW); 185 | } 186 | fastBlinkState = !fastBlinkState; 187 | } 188 | 189 | //Blink handler, execute every 2 seconds 190 | if (cycleCounter % 20 == 0) { 191 | if (blinkYellow) { 192 | if (blinkState) { 193 | digitalWrite(LED_PREHEAT, HIGH); 194 | } else { 195 | digitalWrite(LED_PREHEAT, LOW); 196 | } 197 | } else if (blinkRed) { 198 | if (blinkState) { 199 | digitalWrite(LED_REFLOW, HIGH); 200 | } else { 201 | digitalWrite(LED_REFLOW, LOW); 202 | } 203 | } 204 | blinkState = !blinkState; 205 | } 206 | 207 | //Cycle printout 208 | //USBSerial_println("cycle"); 209 | cycleCounter++; 210 | if (cycleCounter > 600) { 211 | cycleCounter = 0; 212 | } 213 | } 214 | -------------------------------------------------------------------------------- /firmware/reflow/signals.ino: -------------------------------------------------------------------------------- 1 | //When the reflow starts, preheat leds will fast blink 2 | //to indicate auto reflow will start in 5 seconds 3 | void playStartingLEDBlinks(){ 4 | digitalWrite(LED_PREHEAT, LOW); 5 | for(int i = 0; i < 10; i++){ 6 | digitalWrite(LED_PREHEAT, HIGH); 7 | delay(200); 8 | digitalWrite(LED_PREHEAT, LOW); 9 | delay(200); 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /firmware/reflow/utils.ino: -------------------------------------------------------------------------------- 1 | //Read Temp read the current temperature of the hotplate 2 | /* 3 | * Read Current temperature from ADC 4 | * The ADC is reading from a voltage divider 5 | * 5V --- 1k Ohm --- (ADC) --- 100k NTC --- GND 6 | * 7 | * ADC Reading / Temperature (degree C) 8 | * 250 / 25 9 | * 225 / 100 10 | * 155 / 160 (Preheat Temp) 11 | * 123 / 220 (Reflow Temp) 12 | * 100 / 240 (Hard cutoff Temp) 13 | * 14 | * Each reading takes around 100ms 15 | */ 16 | int readTemp() { 17 | int numReadings = 10; // Number of readings to average 18 | int totalSensorValue = 0; 19 | 20 | for (int i = 0; i < numReadings; ++i) { 21 | totalSensorValue += analogRead(TEMP_PIN); 22 | delay(10); // Optional: add a small delay between readings if needed 23 | } 24 | 25 | // Calculate the average sensor value 26 | int averageSensorValue = totalSensorValue / numReadings; 27 | 28 | return averageSensorValue; 29 | } 30 | 31 | //Update heater power state base on temp reading 32 | //The hotter the plate, the smaller the ADC reading 33 | //Return true when the temperature is within target range 34 | bool updateHeaterPowerState(){ 35 | int currentADC = readTemp(); 36 | if (currentADC <= CUTOFF_TEMP_ADC){ 37 | digitalWrite(HEATER_PIN, LOW); 38 | USBSerial_println("!!! OVERHEAT !!!"); 39 | digitalWrite(LED_PREHEAT, HIGH); 40 | digitalWrite(LED_REFLOW, HIGH); 41 | return false; 42 | } 43 | if (currentADC > targetTempADC + offset){ 44 | //Temperature too low. Turn on the heater 45 | analogWrite(HEATER_PIN, targetPwrPWM); 46 | //USBSerial_print("+ "); 47 | //USBSerial_println(currentADC); 48 | return false; 49 | }else if (currentADC < targetTempADC - offset){ 50 | //Temperature too high. Turn off the heater 51 | analogWrite(HEATER_PIN, 0); 52 | //USBSerial_print("- "); 53 | //USBSerial_println(currentADC); 54 | return false; 55 | }else{ 56 | //Within range. Keep the current state 57 | return true; 58 | } 59 | } 60 | 61 | //Update Key States handle touch button events listening and global state update 62 | void updateKeyStates(){ 63 | TouchKey_Process(); 64 | uint8_t touchResult = TouchKey_Get(); 65 | 66 | //Start button, require hold down for 3 seconds to start 67 | if (touchResult & (1 << 2)) { 68 | startCountdown--; 69 | if (startCountdown <= 0 && !reflowing){ 70 | /* START REFLOW PROCESS - PREHEAT */ 71 | USBSerial_println("!!! Reflow Started !!!"); 72 | reflowing = true; 73 | startCountdown = 0; //Prevent it from going underflow 74 | playStartingLEDBlinks(); //Play fast blink start warning 75 | targetTempADC = PREHEAT_START_ADC; //Set the target temp to preheat starting temp 76 | targetPwrPWM = PREHEAT_PWR_PWM; //Set power rating to preheat 77 | reflowStages = 1; //Set the reflow stage to preheating 78 | 79 | //Set the blinking LED status to off 80 | blinkYellow = false; 81 | blinkRed = false; 82 | fastblinkRed = false; 83 | digitalWrite(LED_PREHEAT, HIGH); //Light up the preheat LED 84 | 85 | } 86 | } else { 87 | //Touch released 88 | startCountdown = HOLDSTART_TIME; 89 | } 90 | 91 | //Stop button, stop immediately 92 | if (touchResult & (1 << 5)) { 93 | reflowing= false; 94 | USBSerial_println("Reflow Stopped"); 95 | //Set target temperature to room temp and shut down heater 96 | targetTempADC = COOLDOWN_TEMP_ADC; 97 | targetPwrPWM = 0; 98 | 99 | //Set yellow LED to slow blinkRed 100 | digitalWrite(LED_REFLOW, LOW); 101 | digitalWrite(LED_PREHEAT, LOW); 102 | blinkYellow = true; 103 | blinkRed = false; 104 | fastblinkRed = false; 105 | 106 | //Set reflow stage to standby 107 | reflowStages = 0; 108 | } 109 | } 110 | -------------------------------------------------------------------------------- /model/base.ipt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tobychui/MCH-PD-Automatic-Reflow-Hotplate/d20e28c2106b5c26850c6e21c75fcf41419833f8/model/base.ipt -------------------------------------------------------------------------------- /model/base.stl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tobychui/MCH-PD-Automatic-Reflow-Hotplate/d20e28c2106b5c26850c6e21c75fcf41419833f8/model/base.stl -------------------------------------------------------------------------------- /model/wood_supp.stl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tobychui/MCH-PD-Automatic-Reflow-Hotplate/d20e28c2106b5c26850c6e21c75fcf41419833f8/model/wood_supp.stl -------------------------------------------------------------------------------- /model/wood_suppv2.dwg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tobychui/MCH-PD-Automatic-Reflow-Hotplate/d20e28c2106b5c26850c6e21c75fcf41419833f8/model/wood_suppv2.dwg -------------------------------------------------------------------------------- /model/wood_suppv3.ipt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tobychui/MCH-PD-Automatic-Reflow-Hotplate/d20e28c2106b5c26850c6e21c75fcf41419833f8/model/wood_suppv3.ipt -------------------------------------------------------------------------------- /package/package-zh.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tobychui/MCH-PD-Automatic-Reflow-Hotplate/d20e28c2106b5c26850c6e21c75fcf41419833f8/package/package-zh.png -------------------------------------------------------------------------------- /package/package-zh.psd: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tobychui/MCH-PD-Automatic-Reflow-Hotplate/d20e28c2106b5c26850c6e21c75fcf41419833f8/package/package-zh.psd -------------------------------------------------------------------------------- /package/package.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tobychui/MCH-PD-Automatic-Reflow-Hotplate/d20e28c2106b5c26850c6e21c75fcf41419833f8/package/package.png -------------------------------------------------------------------------------- /package/package.psd: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tobychui/MCH-PD-Automatic-Reflow-Hotplate/d20e28c2106b5c26850c6e21c75fcf41419833f8/package/package.psd -------------------------------------------------------------------------------- /pcb/v4.1/BOM v4.1 modified.csv: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tobychui/MCH-PD-Automatic-Reflow-Hotplate/d20e28c2106b5c26850c6e21c75fcf41419833f8/pcb/v4.1/BOM v4.1 modified.csv -------------------------------------------------------------------------------- /pcb/v4.1/Gerber_PCB_Reflow Hotplate v4.1.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tobychui/MCH-PD-Automatic-Reflow-Hotplate/d20e28c2106b5c26850c6e21c75fcf41419833f8/pcb/v4.1/Gerber_PCB_Reflow Hotplate v4.1.zip -------------------------------------------------------------------------------- /pcb/v4.1/PickAndPlace_PCB_Reflow Hotplate v4_2023-10-31.csv: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tobychui/MCH-PD-Automatic-Reflow-Hotplate/d20e28c2106b5c26850c6e21c75fcf41419833f8/pcb/v4.1/PickAndPlace_PCB_Reflow Hotplate v4_2023-10-31.csv -------------------------------------------------------------------------------- /pcb/v6/Gerber_Reflow-Hotplate_PCB_Reflow-Hotplate-v6_2024-05-24r2.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tobychui/MCH-PD-Automatic-Reflow-Hotplate/d20e28c2106b5c26850c6e21c75fcf41419833f8/pcb/v6/Gerber_Reflow-Hotplate_PCB_Reflow-Hotplate-v6_2024-05-24r2.zip -------------------------------------------------------------------------------- /pcb/v7/Gerber_Reflow-Hotplate_PCB_Reflow-Hotplate-v7.1_2024-06-12r2.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tobychui/MCH-PD-Automatic-Reflow-Hotplate/d20e28c2106b5c26850c6e21c75fcf41419833f8/pcb/v7/Gerber_Reflow-Hotplate_PCB_Reflow-Hotplate-v7.1_2024-06-12r2.zip -------------------------------------------------------------------------------- /photo/0.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tobychui/MCH-PD-Automatic-Reflow-Hotplate/d20e28c2106b5c26850c6e21c75fcf41419833f8/photo/0.jpg -------------------------------------------------------------------------------- /photo/1.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tobychui/MCH-PD-Automatic-Reflow-Hotplate/d20e28c2106b5c26850c6e21c75fcf41419833f8/photo/1.jpg -------------------------------------------------------------------------------- /photo/2.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tobychui/MCH-PD-Automatic-Reflow-Hotplate/d20e28c2106b5c26850c6e21c75fcf41419833f8/photo/2.jpg -------------------------------------------------------------------------------- /photo/3.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tobychui/MCH-PD-Automatic-Reflow-Hotplate/d20e28c2106b5c26850c6e21c75fcf41419833f8/photo/3.jpg -------------------------------------------------------------------------------- /photo/4.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tobychui/MCH-PD-Automatic-Reflow-Hotplate/d20e28c2106b5c26850c6e21c75fcf41419833f8/photo/4.jpg -------------------------------------------------------------------------------- /photo/5.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tobychui/MCH-PD-Automatic-Reflow-Hotplate/d20e28c2106b5c26850c6e21c75fcf41419833f8/photo/5.jpg -------------------------------------------------------------------------------- /photo/6.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tobychui/MCH-PD-Automatic-Reflow-Hotplate/d20e28c2106b5c26850c6e21c75fcf41419833f8/photo/6.jpg -------------------------------------------------------------------------------- /schematic/CH552G.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tobychui/MCH-PD-Automatic-Reflow-Hotplate/d20e28c2106b5c26850c6e21c75fcf41419833f8/schematic/CH552G.png -------------------------------------------------------------------------------- /schematic/IP2721.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tobychui/MCH-PD-Automatic-Reflow-Hotplate/d20e28c2106b5c26850c6e21c75fcf41419833f8/schematic/IP2721.png -------------------------------------------------------------------------------- /schematic/Reflow curve.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tobychui/MCH-PD-Automatic-Reflow-Hotplate/d20e28c2106b5c26850c6e21c75fcf41419833f8/schematic/Reflow curve.png --------------------------------------------------------------------------------