# 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]))