Hello,
I have an MQ2 sensor on an esp board to measure air quality. This works.
but in the some arduino library I found that it should be able to make some distinction between LPG/CO/SMOKE
the code is not completely clear as I never programmed in with arduino
my question, is this also possible in ESPHome? is it easy to migrate the arduino code to ESPHome.
and most important, is it even possible to make this distinction using this module? or do I just get random numbers?
You can create a custom sensor with ESPHome, see here for clear instructions: Custom Sensor Component — ESPHome
For information about curves, see MQ-2 Smoke/LPG/CO Gas Sensor Module | Sandbox Electronics
Thanks,
that actually helped a lot,
still I have a few follow up questions if you don’t mind.
edit: point 3 looks like log value of val 200 with some rounding issues.
It’s nearly impossible to answer you with the very limited info provided in the opening post. For example what type of board do you have, what have you connected and on which pins, how does your yaml looks like, what does your custom sensor do?
Regarding the lambda, what did you try and what errors did you get?
I do not thibk the arduino code can distinguish. The example here http://sandboxelectronics.com/?p=165 shows lpg increasing as the sensor gets closer to a lit cigarette.
A0
substitutions:
device_name: air-quality-sensor
esphome:
name: ${device_name}
friendly_name: air-quality-sensor
includes:
- my_custom_sensor.h
esp8266:
board: esp01_1m
packages:
base: !include .base.yaml
# i2c:
sensor:
# - platform: adc
# pin: A0
# name: "Air Quality"
# update_interval: 1s
# filters:
# - multiply: 1000
# unit_of_measurement: "%"
# icon: "mdi:percent"
# - platform: sht3xd
# temperature:
# name: "Air Quality Temperature"
# humidity:
# name: "Air Quality Humidity"
# address: 0x44
# update_interval: 1s
- platform: custom
lambda: |-
auto my_sensor = new MyCustomSensor();
App.register_component(my_sensor);
return {my_sensor->air_sensor,my_sensor->airro_sensor,my_sensor->lpg_sensor, my_sensor->gas_sensor, my_sensor->smoke_sensor,my_sensor->ch4_sensor};
sensors:
- name: "Air Quality"
unit_of_measurement: "%"
accuracy_decimals: 5
- name: "Air Quality Ro"
unit_of_measurement: "%"
accuracy_decimals: 5
- name: "My Custom lpg Sensor"
unit_of_measurement: "%"
accuracy_decimals: 5
- name: "My Custom gas Sensor"
unit_of_measurement: "%"
accuracy_decimals: 5
- name: "My Custom smoke Sensor"
unit_of_measurement: "%"
accuracy_decimals: 5
- name: "My Custom methane Sensor"
unit_of_measurement: "%"
accuracy_decimals: 5
light:
- platform: status_led
id: stat_led
pin:
number: GPIO2
inverted: yes
and my custom code, it’s almost equal to the arduino one, made a few small changes
#include "esphome.h"
class MyCustomSensor : public PollingComponent {
public:
Sensor *air_sensor = new Sensor();
Sensor *airro_sensor = new Sensor();
Sensor *lpg_sensor = new Sensor();
Sensor *gas_sensor = new Sensor();
Sensor *smoke_sensor = new Sensor();
Sensor *ch4_sensor = new Sensor();
MyCustomSensor() : PollingComponent(1000) {}
/************************Hardware Related Macros************************************/
#define MQ_PIN (0) //define which analog input channel you are going to use
#define RL_VALUE (5) //define the load resistance on the board, in kilo ohms
#define RO_CLEAN_AIR_FACTOR (9.83) //RO_CLEAR_AIR_FACTOR=(Sensor resistance in clean air)/RO,
//which is derived from the chart in datasheet
/***********************Software Related Macros************************************/
#define CALIBARAION_SAMPLE_TIMES (50) //define how many samples you are going to take in the calibration phase
#define CALIBRATION_SAMPLE_INTERVAL (500) //define the time interal(in milisecond) between each samples in the
//cablibration phase
#define READ_SAMPLE_INTERVAL (50) //define how many samples you are going to take in normal operation
#define READ_SAMPLE_TIMES (5) //define the time interal(in milisecond) between each samples in
//normal operation
//https://thestempedia.com/tutorials/interfacing-mq-2-gas-sensor-with-evive/
/*****************************Globals***********************************************/
float LPGCurve[3] = {2.3,0.21,-0.454838059}; //two points are taken from the curve.
//with these two points, a line is formed which is "approximately equivalent"
//to the original curve.
//data format:{ x, y, slope}; point1: (lg200, 0.21), point2: (lg10000, -0.59)
float COCurve[3] = {2.3,0.72,-0.33975668}; //two points are taken from the curve.
//with these two points, a line is formed which is "approximately equivalent"
//to the original curve.
//data format:{ x, y, slope}; point1: (lg200, 0.72), point2: (lg10000, 0.15)
float SmokeCurve[3] ={2.3,0.53,-0.44340257}; //two points are taken from the curve.
//with these two points, a line is formed which is "approximately equivalent"
//to the original curve.
//data format:{ x, y, slope}; point1: (lg200, 0.53), point2: (lg10000, -0.22)
float CH4Curve[3] ={2.3, 0.47712125472, -0.372003751}; //Methane
float Ro = 10; //Ro is initialized to 10 kilo ohms
void setup() override {
Ro = MQCalibration(MQ_PIN); //Calibrating the sensor. Please make sure the sensor is in clean air
//when you perform the calibration
}
// void loop() override {
// // This will be called by App.loop()
// }
void update() override {
float air = MQRead(MQ_PIN);
air_sensor -> publish_state(air);
float airRo = air/Ro;
airro_sensor -> publish_state(airRo);
float lpg = MQGetPercentage(air,LPGCurve);// MQGetGasPercentage(MQRead(MQ_PIN)/Ro,GAS_LPG);
lpg_sensor -> publish_state(lpg);
float gas = MQGetPercentage(airRo,COCurve);//MQGetGasPercentage(MQRead(MQ_PIN)/Ro,GAS_CO);
gas_sensor -> publish_state(gas);
float smoke = MQGetPercentage(airRo,SmokeCurve);//MQGetGasPercentage(MQRead(MQ_PIN)/Ro,GAS_SMOKE);
smoke_sensor -> publish_state(smoke);
float ch4 = MQGetPercentage(airRo,CH4Curve);
ch4_sensor -> publish_state(ch4);
}
/****************** MQResistanceCalculation ****************************************
Input: raw_adc - raw value read from adc, which represents the voltage
Output: the calculated sensor resistance
Remarks: The sensor and the load resistor forms a voltage divider. Given the voltage
across the load resistor and its resistance, the resistance of the sensor
could be derived.
************************************************************************************/
float MQResistanceCalculation(int raw_adc)
{
return ( ((float)RL_VALUE*(1023-raw_adc)/raw_adc));
}
/***************************** MQCalibration ****************************************
Input: mq_pin - analog channel
Output: Ro of the sensor
Remarks: This function assumes that the sensor is in clean air. It use
MQResistanceCalculation to calculates the sensor resistance in clean air
and then divides it with RO_CLEAN_AIR_FACTOR. RO_CLEAN_AIR_FACTOR is about
10, which differs slightly between different sensors.
************************************************************************************/
float MQCalibration(int mq_pin)
{
int i;
float val=0;
for (i=0;i<CALIBARAION_SAMPLE_TIMES;i++) { //take multiple samples
val += MQResistanceCalculation(analogRead(mq_pin));
delay(CALIBRATION_SAMPLE_INTERVAL);
}
val = val/CALIBARAION_SAMPLE_TIMES; //calculate the average value
val = val/RO_CLEAN_AIR_FACTOR; //divided by RO_CLEAN_AIR_FACTOR yields the Ro
//according to the chart in the datasheet
return val;
}
/***************************** MQRead *********************************************
Input: mq_pin - analog channel
Output: Rs of the sensor
Remarks: This function use MQResistanceCalculation to caculate the sensor resistenc (Rs).
The Rs changes as the sensor is in the different consentration of the target
gas. The sample times and the time interval between samples could be configured
by changing the definition of the macros.
************************************************************************************/
float MQRead(int mq_pin)
{
int i;
float rs=0;
for (i=0;i<READ_SAMPLE_TIMES;i++) {
rs += MQResistanceCalculation(analogRead(mq_pin));
delay(READ_SAMPLE_INTERVAL);
}
rs = rs/READ_SAMPLE_TIMES;
return rs;
}
/***************************** MQGetGasPercentage **********************************
Input: rs_ro_ratio - Rs divided by Ro
gas_id - target gas type
Output: ppm of the target gas
Remarks: This function passes different curves to the MQGetPercentage function which
calculates the ppm (parts per million) of the target gas.
************************************************************************************/
// int MQGetGasPercentage(float rs_ro_ratio, int gas_id)
// {
// if ( gas_id == GAS_LPG ) {
// return MQGetPercentage(rs_ro_ratio,LPGCurve);
// } else if ( gas_id == GAS_CO ) {
// return MQGetPercentage(rs_ro_ratio,COCurve);
// } else if ( gas_id == GAS_SMOKE ) {
// return MQGetPercentage(rs_ro_ratio,SmokeCurve);
// }
// return 0;
// }
/***************************** MQGetPercentage **********************************
Input: rs_ro_ratio - Rs divided by Ro
pcurve - pointer to the curve of the target gas
Output: ppm of the target gas
Remarks: By using the slope and a point of the line. The x(logarithmic value of ppm)
of the line could be derived if y(rs_ro_ratio) is provided. As it is a
logarithmic coordinate, power of 10 is used to convert the result to non-logarithmic
value.
************************************************************************************/
int MQGetPercentage(float rs_ro_ratio, float *pcurve)
{
return (pow(10,( ((log(rs_ro_ratio)-pcurve[1])/pcurve[2]) + pcurve[0])));
}
};
I tried this, in different ways, : = ( )
lambda: |-
auto my_sensor = new MyCustomSensor();
my_sensor->MQ_PIN: A0
App.register_component(my_sensor);
return {my_sensor->air_sensor,my_sensor->airro_sensor,my_sensor->lpg_sensor, my_sensor->gas_sensor, my_sensor->smoke_sensor,my_sensor->ch4_sensor};
but always get:
Compiling /data/air-quality-sensor/.pioenvs/air-quality-sensor/src/main.cpp.o
In file included from src/main.cpp:42:
/config/esphome/air-quality-sensor.yaml: In lambda function:
src/my_custom_sensor.h:15:48: error: expected unqualified-id before '(' token
15 | #define MQ_PIN (0) //define which analog input channel you are going to use
| ^
/config/esphome/air-quality-sensor.yaml:37:18: note: in expansion of macro 'MQ_PIN'
37 | my_sensor->MQ_PIN: A0
| ^~~~~~
*** [/data/air-quality-sensor/.pioenvs/air-quality-sensor/src/main.cpp.o] Error 1
========================= [FAILED] Took 13.74 seconds =========================
I think you are correct,
I found this LPG increasing also on my smoke tests. But I thought that was just a minor misconfiguration in the curve at the time. Now I’m actually wondering how it would even be possible for 1 analog reader to make the distinction between the different gasses.
I think the sensor can detect any of those gasses but not determine which one it actually is.
And that makes the default adc platform on ESPHome actually the best suitable one.
Someone tried something in code and got some kind of result and this code is exactly copied everywhere but doesn’t work as described.
Ah, now kind of understand what you are trying to achieve.
Regarding the lambda: this my_sensor->MQ_PIN: A0 is invalid C(++) code. Firstly, should be ‘=’ instead of ‘:’ and secondly, MQ_PIN is a #define which you can’t overrule with code. It’s a preprocessor definition.
Simplest solution would be to change it to #define MQ_PIN (17) (A0 = pin 17) and remove the failing line from the lambda.
But if you want to have it configurable, change it to this:
int MqPin = MQ_PIN;
MyCustomSensor(int mqPin) : PollingComponent(1000) {
MqPin = mqPin;
}
...
void setup() override {
Ro = MQCalibration(MqPin);
}
void update() override {
float air = MQRead(MqPin);
...
And in the Lambda:
lambda: |-
auto my_sensor = new MyCustomSensor(A0);
App.register_component(my_sensor);
...
When you also want to have update interval configurable, can do something similarly.
Also note that you are using board esp01_1m which does not expose pin A0, although it’s configured as base pin 17 for all ESP8266s. The digital pins can be different per board so when you use digital pins in the future, better change it to the board type that you’re actually using.
thanks,
now I know, but my next custom sensor, this one as mentioned above probably will never work as expected. Still I wanted to know;)
about the board it’s esp12f, but that’s not allowed and esp12e has about the same specs. so I choose that one.
I actually thought the pinout for all esp8266 was the same, the only difference being memory. but now I have 3MB more 