Gas Leakage Detection with Buzzer System using ATmega

This guide will help you build a gas leakage detection system using an ATmega microcontroller. The system detects gas leakage and triggers a buzzer to alert users, providing a simple yet effective safety solution for environments where gas leaks are a concern.

Components Required

• ATmega microcontroller (e.g., ATmega328P)
• MQ-2 Gas Sensor (for detecting various gases including methane, LPG, and smoke)
• Buzzer (active or passive)
• Connecting wires and breadboard
• Power supply (e.g., 5V DC adapter or battery)
• Resistors (as required for sensor and buzzer)

Setting Up the Hardware

Follow these steps to set up the hardware:

1. Connect the Gas Sensor

   Connect the MQ-2 gas sensor to the ATmega microcontroller. The sensor typically has four pins: VCC, GND, Analog output (AOUT), and Digital output (DOUT). Connect VCC to the 5V supply, GND to ground, AOUT to an analog input pin of the ATmega, and DOUT to a digital input pin if you want to use the digital output.

2. Connect the Buzzer

   Attach the buzzer to a digital output pin on the ATmega. Connect one pin of the buzzer to the digital output pin and the other to ground. You may need a resistor in series with the buzzer depending on its specifications.

3. Power the System

   Ensure that the ATmega and all connected components are powered correctly. Use a 5V DC power supply or battery to power the microcontroller and sensors.

Programming the ATmega

Write the code for the ATmega microcontroller to read gas sensor data and trigger the buzzer when gas levels exceed a predefined threshold. Below is a basic outline of the code:

                #include <avr/io.h>
                #include <util/delay.h>

                #define GAS_SENSOR_PIN 0 // Analog pin for MQ-2 sensor
                #define BUZZER_PIN 1     // Digital pin for buzzer

                void setup() {
                    // Set buzzer pin as output
                    DDRB |= (1 << BUZZER_PIN);
                    
                    // Set ADC prescaler to 64 for 16MHz clock
                    ADCSRA |= (1 << ADPS2) | (1 << ADPS1);
                    
                    // Set ADC reference to AVCC
                    ADMUX |= (1 << REFS0);
                }

                uint16_t read_gas_sensor() {
                    ADMUX = (ADMUX & 0xF0) | (GAS_SENSOR_PIN & 0x0F); // Select the gas sensor pin
                    ADCSRA |= (1 << ADSC); // Start conversion
                    while (ADCSRA & (1 << ADSC)); // Wait for conversion to complete
                    return ADC;
                }

                void loop() {
                    uint16_t gas_level = read_gas_sensor();
                    
                    if (gas_level > 300) { // Adjust threshold as needed
                        PORTB |= (1 << BUZZER_PIN); // Turn on buzzer
                    } else {
                        PORTB &= ~(1 << BUZZER_PIN); // Turn off buzzer
                    }
                    
                    _delay_ms(1000); // Wait 1 second before next reading
                }

                int main() {
                    setup();
                    while (1) {
                        loop();
                    }
                }
            

This code reads the analog output from the gas sensor and activates the buzzer if the gas level exceeds a predefined threshold. Adjust the threshold value based on your requirements and sensor calibration.

Testing and Calibration

Test the system by exposing the gas sensor to different gas concentrations and ensuring the buzzer activates correctly. Calibrate the sensor by adjusting the threshold value in the code to match the sensitivity required for your application.