Introduction: Automatic Kitchen Hood Activation With Induction Cooktop (with Arduino)
Description:
I wanted to automate the operation of the kitchen hood, so I started a new project. And the result? Now, when I turn on my induction cooktop, it automatically triggers both my kitchen hood and its LED lights. Even though the cooktop and hood aren't physically connected, I made them talk wirelessly, creating a radio link between the two.
Why This Project:
The motivation behind this project stemmed from everyday cooking scenarios. Most of the time, when we cook, we manually switched on the range hood's LED light and the hood itself. While this manual operation worked, it often led to us forgetting to switch off the hood after cooking, primarily because we preferred leaving it on for a while to clear lingering odors and steam. The same forgetfulness applied to the LED light.
So, the question arose: How could I automate this process? Initially, I explored various solutions involving temperature sensors to detect cooking activity or motion sensors. However, these options seemed impractical and potentially unreliable. The breakthrough came with the idea of having the hood and LED light respond to the induction cooktop's activation.
Yet, two challenges remained to be solved. The first was to determine when the induction cooktop turned on and off. The second was how to transmit this information to the range hood without adding extra wiring.
Solutions:
For the first problem, I employed a smart solution, a current detection device at the power cable of the induction cooktop (M3050 Induction Relay Switch). Thank you, Tomaz, for bringing this to light :)
To tackle the second issue, I implemented wireless communication using NRF24L01 Wireless modules.
Arduino as the Brain:
All the logic behind this automation was entrusted to an Arduino. My previous experience with Arduino made it a natural choice for this project.
Versatility and Compatibility:
I've tried to designed this system to be adaptable to various hood and induction cooktop models, as well as glass-ceramic cooktops.
Safety and Reliability:
A paramount concern was to ensure that the installation of the transmitter for the induction cooktop and the receiver for the kitchen hood would not interfere with the existing electronics in a way that could affect their proper functioning or potentially lead to malfunctions.
With the installation and setup completed, I can now enjoy a more seamless and enjoyable cooking experience, with the kitchen hood and LED lighting effortlessly responding to my cooking activities.
Impressive Outcome:
The project's outcome exceeded my initial expectations, and even my wife, despite some initial disruptions during testing and debugging, is now quite pleased with the solution :)
A prerequisite for the implementation of the project:
Before getting serious about the project, check if you can access the digitalbuttons on the hood as you will need to establish wire connections to the turn on hood and LED control buttons (in Step 3). If you have buttons with ON and OFF positions, then you will have to to adjust-change the Receiver code (in Step 7).
Also check if you have physical access to the power cable of the induction or glass-ceramic cooktop (in Step 1).
Supplies
The supplies for this project are as follows:
Software:
- Arduino IDE
Tools:
- Soldering iron
- Power Drill (for making holes)
- Small pliers or olfa knife (for wires preparation)
- Multimeter (for Step 3 and Step 4)
- USB cable for Arduino programming
Components:
- 1x M3050 Induction Relay Switch Module (Current Detection) - aliexpress.com from 6€
- 2x RF-Arduino Nano (ATMEGA328P) Integrated NRF24L01 - aliexpress.com from 5€/piece
- 2x 5V low level trigger Relay Module For Arduino - aliexpress.com from 0.6€/piece
- 1xLM2596 DC-DC Step-down Power Supply Module Voltage Regulator - aliexpress.com from 0.7€
- 1x 12V EU US Plug Driver Adapter AC110V 220V - aliexpress.com from 2€
- 2x small boxes (I printed them with 3D printer: Universal Project Box), https://www.thingiverse.com/thing:4801005/files or buy DIY Enclosure Boxes - aliexpress.com from 1€/piece
- 1x a few wires to connect everything in the box
Step 1: Connecting and Testing the M3050 Induction Relay Switch
First, turn off the fuse that powers the induction cooktop in the circuit breaker box!
Then connect the M3050 Induction Relay Switch. Do this by passing the phase L1, which powers the induction cooktop, through the detection hole of the M3050. If the induction cooktop uses multiple phases, also pass the other phase, L2, through the detector (as shown in the picture). A great feature of the M3050 is that it doesn't require an external power supply; it operates using the induced current that it measures or detects.
The M3050 has two LEDs: red and green. If the green LED is lit, it means no current is detected (OFF), and if the red LED is lit, it indicates that current is detected (ON). You can adjust the sensitivity at which the relay switches by using a screwdriver (Low - High) that you can turn as needed to achieve the correct detection. So, the LED should light up in red (ON) when the induction or ceramic cooktop is on and in green when it's off. Even if the induction cooktop momentarily turns off at lower power levels for a few seconds, it won't affect the proper functioning as this is ignored by the code in the transmitter part.
Step 2: Installing the Transmitter Module
In this step, we will set up the transmitter module (Arduino nano with NRF24L01). The transmitter module is responsible for detecting the status of the induction or glass ceramic cooktop and transmitting this information wirelessly to the receiver which is located at the hood.
Connect as shown in the picture. D2 is set as input, it is configured as an pullup (To prevent the input from floating). When M3050 detect a current, the relay (with D2 and GND inputs) closes, so D2 connects to GND.
For Arduino nano power supply, I used some old 12V power supply adapter.
At the end, when everything works, the transmitter can be closed in the case. For further programming, I left a hole on the case to access the Arduino USB connector.
As you can see from the photo, I didn't spend too much time fixing the Arduino circuit in the box. I just used my daughter's 3D pen into which I inserted the same 3D filament with which I printed the box and somehow glued the arduino board in.
Step 3: Wiring to Hood Control Buttons
First, turn off the fuse that powers the kitchen hood in the circuit breaker box!
Now you need to establish connections to the control buttons on your kitchen hood that are responsible for turning on the hood and LED lights manually. By making these connections, you'll be able to automate the hood and lighting control while still allowing manual operation when needed.
- Examine your kitchen hood to locate how to access the buttons used to turn on the hood and LED lights manually. Usually there is a front on the hood that can be removed so you can get the electrical circuit with the buttons out.
- Identify the pins on these buttons. When you press the button two pins should connect. (use multimeter)
- Wire those two pins with wires for LED and for (turn on the hood) buttons.(use soldering iron)
I used an old RJ11 telephone cable for the wires :)
Step 4: Optional Wiring for Hood and LED Status
In this "optional" step, you have the opportunity to wire your Arduino (receiver) to the kitchen hood to determine the status of both the LED lights and the hood itself. While this step is not necessary for basic functionality, it can enhance your project by providing feedback on the status of the hood and lighting. Basically, it will allow you to control your hood manually even when the logic of automation took over.
However, the code is currently written to require these statuses for proper operation. If you do not use them or cannot obtain them from the hood, the code will need to be adapted accordingly!
Examine your kitchen hood main electronic circuit for any available pins (points on the circuit) that can be used to detect the status of the LED lights and the hood itself.
I found these points on the relays on which the voltage of 18 V appeared when the status was on. Then I just reduced this voltage to 5V using a resistor divider and connect it to LED and HOOD status input shown on the diagram in the next step.
Don't forget to connect the ground of the electronic circuit of the hood to the ground of the Arduino receiver.
In my case, this was already done as I stole the power supply for the Arduino receiver from the hood circuit itself. I just have to stabilize the 18 V voltage and lower it to 12 V first, to use it as, described in the following steps.
Step 5: Setting Up the Receiver Module
In this step, you'll be configuring and installing the receiver module. This module receives wireless signals from the transmitter module, enabling it to control the kitchen hood and LED lights automatically.
Connect the components as illustrated. D2 and D3 are set as outputs to trigger the Relay, which controls the LED and HOOD for On and Off functions. I used a 5V power supply from Arduino to power the Relays. Note that I used Low-Level trigger Relays, meaning they switch ON when Arduino outputs go to 0V. If you have high-level trigger relays, simply invert the logic in the code.
Pin D4 and D5 serve as inputs for LED and HOOD status, as described in the previous step.
For the main power supply of Arduino Nano, I utilized power from the hood itself (15-18 V) and stabilized it to 12 V with a DC-DC step-down power supply.
Once everything is connected, you can enclose the transmitter in the case. I've left a hole on the case for programming, providing access to the Arduino USB connector.
Step 6: The Code for Transmitter Module
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
RF24 radio(10, 9); // CE, CSN NOTE: For other versions of nRF24L01(+) modules, CE and CSN may use different pins (9,10 or 7,8, ...)
int previousInductionState = LOW; // Set the initial state
int InductionState = LOW; // Set the initial state
int previousDetectedInduction = LOW; // Set the initial state
unsigned long startTime = 0;
void setup() {
radio.begin();
radio.openWritingPipe(0x1A2B3C4D); // Receiver address
radio.setPALevel(RF24_PA_LOW); // Set radio power to LOW
radio.stopListening();
pinMode(2, INPUT_PULLUP); // Set pin 2 as input - HIGH when induction is off
}
void loop() {
int detectedInduction = !digitalRead(2); // Read the current state; HIGH when LOW is detected (induction is on)
// This part of the code makes sure that the information about whether the Induction Cooktop is turned off, is sent only when the Induction Cooktop is turned off continuously for at least 5 seconds.
// The lower power levels of the induction usually turn on/off the power every second or two, which we don't want to bother the receiver.
if (previousDetectedInduction == HIGH && detectedInduction == LOW) {
startTime = millis(); // Reset the timer on every change from HIGH to LOW
previousDetectedInduction = LOW;
}
if (detectedInduction == LOW && (millis() - startTime) >= 5000)
InductionState = LOW; // Wait for 5 seconds, and if detectedInduction is still continuously LOW, change the state to LOW
if (detectedInduction == HIGH) {
InductionState = HIGH;
previousDetectedInduction = HIGH;
}
// Sending the status of the Induction Cooktop to the receiver, but only when the state changes.
if (InductionState != previousInductionState) {
radio.write(&InductionState, sizeof(InductionState));
previousInductionState = InductionState; // Update the previous state
}
delay(100); // Small delay for reading stability
}
Attachments
Step 7: The Code for Receiver Module
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
RF24 radio(10, 9); // CE, CSN // NOTE: For other versions of nRF24L01(+) modules, CE and CSN may use different pins (9,10 or 7,8, ...)
// Pins: D9,D10, D11, D12, D13 are typically reserved for nRF24L01+ modules
unsigned long ledTimer = 0; // The timer counts from the time the induction cooker is turned on
unsigned long hoodTimer = 0; // The timer counts from the time the induction cooker is turned on
unsigned long ledTimer1 = 0; // The timer counts from the time the induction cooker turns on the LED (relay)
unsigned long hoodTimer1 = 0; // The timer counts from the time the induction cooker turns on the HOOD (relay)
unsigned long LEDmanuallyTurnedOnTimer = 0; // The timer counts from the time the LED is manually turned on
unsigned long HOODmanuallyTurnedOnTimer = 0; // The timer counts from the time the HOOD is manually turned on
unsigned long HOODturnOnTimer = 0; // The timer counts from the time the induction cooker is turned on to when the HOOD is turned on (with a delay)
bool ledActive = false; // LED state - true when automatically turned on via induction
bool hoodActive = false; // HOOD state - true when automatically turned on via induction
bool LEDmanuallyTurnedOn = false; // LED state - true when manually turned on
bool LEDmanuallyTurnedOffAuto = false; // LED state - true when manually turned off after being turned on via induction
bool HOODmanuallyTurnedOn = false; // HOOD state - true when manually turned on
bool HOODmanuallyTurnedOffAuto = false; // HOOD state - true when manually turned off after being turned on via induction
bool LEDmanuallyTurnedOnDuringInduction = false; // LED state - true when manually turned on after or during induction
bool HOODmanuallyTurnedOnDuringInduction = false; // HOOD state - true when manually turned on after or during induction
unsigned long HOODTurnOnDelay = 40000; // Delay time for turning on the HOOD, default 40s
unsigned long autoTurnOffLEDInduction = 900000; // Time to turn off LED after the induction is turned off, default 15 min
unsigned long autoTurnOffHOODInduction = 120000; // Time to turn off HOOD after the induction is turned off, default 2 min
unsigned long autoTurnOffLEDManual = 3600000; // Time to turn off LED after manual turned on the LED, default 60 min
unsigned long autoTurnOffHOODManual = 3600000; // Time to turn off HOOD after manual turned on the HOOD, default 60 min
int inductionState = LOW; // Initialize the induction variable to LOW = off
int LEDrelay = 2; // Digital output controlling the LED relay
int HOODrelay = 3; // Digital output controlling the HOOD relay
int LEDstatus = 4; // Digital input monitoring whether the LED is turned on
int HOODstatus = 5; // Digital input monitoring whether the HOOD is turned on
bool previousLEDStatus = LOW; // Previous state of the LED
bool previousHOODStatus = LOW; // Previous state of the HOOD
bool currentLEDStatus = LOW; // Current state of the LED
bool currentHOODStatus = LOW; // Current state of the HOOD
void setup() {
pinMode(LEDrelay, OUTPUT); // Output for turning on the LED relay
pinMode(HOODrelay, OUTPUT); // Output for turning on the HOOD relay
pinMode(LEDstatus, INPUT); // Input for checking when the LED is turned on
pinMode(HOODstatus, INPUT); // Input for checking when the HOOD is turned on
digitalWrite(LEDrelay, HIGH); // Turn off the LED relay at startup (@ LOW level trigger relay)
digitalWrite(HOODrelay, HIGH); // Turn off the HOOD relay at startup (@ LOW level trigger relay)
//Serial.begin(9600); // Start serial communication - for debugging
radio.begin();
radio.openReadingPipe(1, 0x1A2B3C4D); // Transmitter/Receiver address, can be arbitrarily set
radio.setPALevel(RF24_PA_LOW); // Set radio power to LOW (the distance between the induction and the HOOD is typically very small)
radio.startListening();
delay(5000);
}
// Function for turning the LED or HOOD relay on and off
void toggleRelay(int pin) {
digitalWrite(pin, LOW);
delay(300); // Short delay to simulate the time it takes to press the button manually; a shorter delay might not be detected by some devices.
digitalWrite(pin, HIGH);
delay(300);
}
void loop() {
currentLEDStatus = !digitalRead(LEDstatus); // Read the LED status - is it on?
currentHOODStatus = !digitalRead(HOODstatus); // Read the HOOD status - is it on?
// Check if the LED has turned on
if (currentLEDStatus == HIGH && previousLEDStatus == LOW) { // The LED has turned on manually
if (millis() - ledTimer1 >= 1500) { // Check if it's outside the time when the induction was running; default 1500ms
LEDmanuallyTurnedOnTimer = millis();
LEDmanuallyTurnedOn = true;
LEDmanuallyTurnedOffAuto = false;
}
else { // LED was not manually turned on because it was turned on by the automatic induction
LEDmanuallyTurnedOn = false;
LEDmanuallyTurnedOnTimer = 0;
}
}
// Check if the LED has turned off
if (currentLEDStatus == LOW && previousLEDStatus == HIGH) { // The LED has turned off manually
LEDmanuallyTurnedOn = false; // The LED is currently off
if (millis() - ledTimer1 >= 1500) { // Check if it's outside the time when the induction was running; default 1500ms
LEDmanuallyTurnedOffAuto = true;
LEDmanuallyTurnedOnTimer = 0;
}
else
LEDmanuallyTurnedOffAuto = false;
}
// Update the previous LED state
previousLEDStatus = currentLEDStatus;
// Check if the HOOD has turned on
if (currentHOODStatus == HIGH && previousHOODStatus == LOW) { // The HOOD has turned on manually
if (millis() - hoodTimer1 >= 1500) { // Check if it's outside the time when the induction was running; default 1500ms
HOODmanuallyTurnedOnTimer = millis();
HOODmanuallyTurnedOn = true;
HOODmanuallyTurnedOffAuto = false;
} else {
// HOOD was not manually turned on because it was turned on by the automatic induction
HOODmanuallyTurnedOn = false;
HOODmanuallyTurnedOnTimer = 0;
}
}
// Check if the HOOD has turned off
if (currentHOODStatus == LOW && previousHOODStatus == HIGH) { // The HOOD has turned off manually
HOODmanuallyTurnedOn = false; // The HOOD is currently off
if (millis() - hoodTimer1 >= 1500) { // Check if it's outside the time when the induction was running; default 1500ms
HOODmanuallyTurnedOffAuto = true;
HOODmanuallyTurnedOnTimer = 0;
}
else
HOODmanuallyTurnedOffAuto = false;
}
// Update the previous HOOD state
previousHOODStatus = currentHOODStatus;
// If the radio is available, check the state of the induction reported by the transmitter
if (radio.available()) {
radio.read(&inductionState, sizeof(inductionState));
}
if (inductionState == HIGH) { // The induction cooker has turned on
ledTimer = millis();
hoodTimer = millis();
if (!ledActive && !LEDmanuallyTurnedOn && !LEDmanuallyTurnedOffAuto) { // Turn on the LED when this condition is met
toggleRelay(LEDrelay); // Turn on the LED relay - for 0.3s
ledActive = true;
ledTimer1 = millis();
}
if (!hoodActive && !HOODmanuallyTurnedOn && !HOODmanuallyTurnedOffAuto) { // Start the HOOD turn-on delay procedure when this condition is met
hoodActive = true;
HOODturnOnTimer = millis();
}
if (LEDmanuallyTurnedOn) // Check if the LED was manually turned on after or during the induction
LEDmanuallyTurnedOnDuringInduction = true;
else
LEDmanuallyTurnedOnDuringInduction = false;
if (HOODmanuallyTurnedOn) // Check if the HOOD was manually turned on after or during the induction
HOODmanuallyTurnedOnDuringInduction = true;
else
HOODmanuallyTurnedOnDuringInduction = false;
}
if (hoodActive && inductionState && !HOODmanuallyTurnedOn && !HOODmanuallyTurnedOffAuto && HOODturnOnTimer > 0 && millis() - HOODturnOnTimer >= HOODTurnOnDelay) { // Turn on HOOD with a delay
toggleRelay(HOODrelay); // Turn on the HOOD relay - for 0.3s
hoodTimer1 = millis();
HOODturnOnTimer = 0; // Reset
}
else if (HOODturnOnTimer > 0 && millis() - HOODturnOnTimer >= HOODTurnOnDelay) {
hoodActive = false;
HOODturnOnTimer = 0; // Reset
}
// Monitoring variable states for debugging:
/*
Serial.print("inductionState: ");
Serial.println(inductionState);
Serial.print("ledActive: ");
Serial.println(ledActive);
Serial.print("hoodActive: ");
Serial.println(hoodActive);
Serial.print("currentLEDStatus: ");
Serial.println(currentLEDStatus);
Serial.print("LEDmanuallyTurnedOn: ");
Serial.println(LEDmanuallyTurnedOn);
Serial.print("LEDmanuallyTurnedOffAuto: ");
Serial.println(LEDmanuallyTurnedOffAuto);
Serial.print("currentHOODStatus: ");
Serial.println(currentHOODStatus);
Serial.print("HOODmanuallyTurnedOn: ");
Serial.println(HOODmanuallyTurnedOn);
Serial.print("HOODmanuallyTurnedOffAuto: ");
Serial.println(HOODmanuallyTurnedOffAuto);
*/
if ((ledActive || LEDmanuallyTurnedOnDuringInduction) && !inductionState && !LEDmanuallyTurnedOffAuto && millis() - ledTimer >= autoTurnOffLEDInduction) { // Turn off the LED after the induction turns off
toggleRelay(LEDrelay); // Turn off the LED relay - for 0.3s
ledActive = false;
LEDmanuallyTurnedOnDuringInduction = false;
LEDmanuallyTurnedOn = false;
}
if ((hoodActive || HOODmanuallyTurnedOnDuringInduction) && !inductionState && !HOODmanuallyTurnedOffAuto && millis() - hoodTimer >= autoTurnOffHOODInduction) { // Turn off the HOOD after the induction turns off
toggleRelay(HOODrelay); // Turn off the HOOD relay - for 0.3s
hoodActive = false;
HOODmanuallyTurnedOnDuringInduction = false;
HOODmanuallyTurnedOn = false;
}
if (LEDmanuallyTurnedOffAuto && millis() - ledTimer1 >= 2000) { // If more than 2s have passed since the last induction-based LED activation and the LED was manually turned off
ledActive = false;
if (!inductionState)
LEDmanuallyTurnedOffAuto = false;
}
if (HOODmanuallyTurnedOffAuto && millis() - hoodTimer1 >= 2000) { // If more than 2s have passed since the last induction-based HOOD activation and the HOOD was manually turned off
hoodActive = false;
if (!inductionState)
HOODmanuallyTurnedOffAuto = false;
}
if (!inductionState && LEDmanuallyTurnedOn && millis() - LEDmanuallyTurnedOnTimer >= autoTurnOffLEDManual) { // If more than X minutes have passed since the last manual LED activation, turn off the LED
toggleRelay(LEDrelay); // Turn off the LED relay - for 0.3s
LEDmanuallyTurnedOn = false;
ledActive = false;
ledTimer = 0;
}
if (!inductionState && HOODmanuallyTurnedOn && millis() - HOODmanuallyTurnedOnTimer >= autoTurnOffHOODManual) { // If more than X minutes have passed since the last manual HOOD activation, turn off the HOOD
toggleRelay(HOODrelay); // Turn off the HOOD relay - for 0.3s
HOODmanuallyTurnedOn = false;
hoodActive = false;
hoodTimer = 0;
}
delay(10);
}
Attachments
Step 8: Uploading the Codes
Download the codes attached in the previous two steps and open it in Arduino IDE.
Download the necessary libraries required for the code.
You can change the timers in code as you wish:
int HOODTurnOnDelay = 40000; // Delay time for turning on the HOOD, default 40s
int autoTurnOffLEDInduction = 900000; // Time to turn off LED after the induction is turned off, default 15 min
int autoTurnOffHOODInduction = 120000; // Time to turn off HOOD after the induction is turned off, default 2 min
int autoTurnOffLEDManual = 3600000; // Time to turn off LED after manual turned on the LED, default 60 min
int autoTurnOffHOODManual = 3600000; // Time to turn off HOOD after manual turned on the HOOD, default 60 min
As you can see, the HOOD and LED turns off at a different time if it was turned on automatically by the induction cooktop or if it was turned on manually. My wish for the HOOD and LED to stay on for 1 hour if turned on manually, and then turn off.
That's all, compile and upload the codes to your Arduino nano Transmitter and Receiver.
Step 9: Conclusion
I hope you will successfully replicate the project and be as satisfied with the solution as we are. If you encounter any challenges, feel free to ask. Additionally, if you identify any errors, especially in the code, please inform me. I apologize in advance for any code complexities as I am a beginner in programming.
Good luck!
![Tim's Mechanical Spider Leg [LU9685-20CU]](https://content.instructables.com/FFB/5R4I/LVKZ6G6R/FFB5R4ILVKZ6G6R.png?auto=webp&crop=1.2%3A1&frame=1&width=306)
