125 lines
5.6 KiB
Python
125 lines
5.6 KiB
Python
# adapted from https://github.com/tutRPi/Raspberry-Pi-Gas-Sensor-MQ
|
|
|
|
import time
|
|
import math
|
|
from machine import ADC,Pin
|
|
|
|
|
|
class MQ:
|
|
# Hardware Related Macros
|
|
RL_VALUE = 10 # define the load resistance on the board, in kilo ohms
|
|
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
|
|
CALIBARAION_SAMPLE_TIMES = 50 # define how many samples you are going to take in the calibration phase
|
|
CALIBRATION_SAMPLE_INTERVAL = 500 # define the time interal(in milisecond) between each samples in the
|
|
# cablibration phase
|
|
READ_SAMPLE_INTERVAL = 50 # define how many samples you are going to take in normal operation
|
|
READ_SAMPLE_TIMES = 5 # define the time interal(in milisecond) between each samples in
|
|
# normal operation
|
|
|
|
# Application Related Macros
|
|
GAS_LPG = 0
|
|
GAS_CO = 1
|
|
GAS_SMOKE = 2
|
|
|
|
def __init__(self, ro=10):
|
|
self.ro = ro
|
|
self.adc = ADC(Pin(34))
|
|
|
|
self.LPGCurve = [2.3, 0.21, -0.47] # 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)
|
|
self.COCurve = [2.3, 0.72, -0.34] # 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)
|
|
self.SmokeCurve = [2.3, 0.53, -0.44] # 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)
|
|
|
|
# print("Calibrating...")
|
|
self.ro = self.MQCalibration()
|
|
# print("Calibration is done...\n")
|
|
# print("Ro=%f kohm" % self.ro)
|
|
|
|
def MQPercentage(self):
|
|
val = {}
|
|
read = self.MQRead()
|
|
val["GAS_LPG"] = self.MQGetGasPercentage(read / self.ro, self.GAS_LPG)
|
|
val["CO"] = self.MQGetGasPercentage(read / self.ro, self.GAS_CO)
|
|
val["SMOKE"] = self.MQGetGasPercentage(read / self.ro, self.GAS_SMOKE)
|
|
return val
|
|
|
|
# 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.
|
|
def MQResistanceCalculation(self, raw_adc):
|
|
return float(self.RL_VALUE * (4095.0 - raw_adc) / float(raw_adc))
|
|
|
|
# MQCalibration
|
|
# 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.
|
|
def MQCalibration(self):
|
|
val = 0.0
|
|
for i in range(self.CALIBARAION_SAMPLE_TIMES): # take multiple samples
|
|
val += self.MQResistanceCalculation(self.adc.read())
|
|
time.sleep(self.CALIBRATION_SAMPLE_INTERVAL / 1000.0)
|
|
|
|
val = val / self.CALIBARAION_SAMPLE_TIMES # calculate the average value
|
|
|
|
val = val / self.RO_CLEAN_AIR_FACTOR # divided by RO_CLEAN_AIR_FACTOR yields the Ro
|
|
# according to the chart in the datasheet
|
|
return val
|
|
|
|
# MQRead
|
|
# 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.
|
|
def MQRead(self):
|
|
rs = 0.0
|
|
|
|
for i in range(self.READ_SAMPLE_TIMES):
|
|
rs += self.MQResistanceCalculation(self.adc.read())
|
|
time.sleep(self.READ_SAMPLE_INTERVAL / 1000.0)
|
|
|
|
rs = rs / self.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.
|
|
def MQGetGasPercentage(self, rs_ro_ratio, gas_id):
|
|
if gas_id == self.GAS_LPG:
|
|
return self.MQGetPercentage(rs_ro_ratio, self.LPGCurve)
|
|
elif gas_id == self.GAS_CO:
|
|
return self.MQGetPercentage(rs_ro_ratio, self.COCurve)
|
|
elif gas_id == self.GAS_SMOKE:
|
|
return self.MQGetPercentage(rs_ro_ratio, self.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.
|
|
def MQGetPercentage(self, rs_ro_ratio, pcurve):
|
|
return math.pow(10, (((math.log(rs_ro_ratio) - pcurve[1]) / pcurve[2]) + pcurve[0]))
|