Merge pull request #85 from miguel5612/codex/implement-temperature-and-humidity-correction-for-all-exampl

Add optional correction factor to API

.github/pull_request_template.md

@@ -12,6 +12,8 @@ Please delete options that are not relevant.
 - [ ] New feature (non-breaking change which adds functionality)
 - [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected)
 - [ ] This change requires a documentation update
+- [ ] I have updated the version in `library.properties` to reflect my changes (advance by 0.01 for minor changes, or a whole number for new features)
+- [ ] I have submitted the pull request
 
 # How Has This Been Tested?
 

CONTRIBUTING.md

@@ -20,3 +20,7 @@ Pull request will be check by three main authors who are linked in
 [REAMDE.md](https://github.com/miguel5612/MQSensorsLib/README.md) and they determine to merge to
 master branch. Later than assessment and debbuging procedures was completed, the contribution 
 will be released.
+
+## Versioning
+
+When making a pull request, please remember to update the `library.properties` file to reflect the changes you've made. If your change is minor, consider advancing the version by 0.01. If you're adding a new feature, you may want to advance the version by a whole number.

README.md

@@ -68,6 +68,7 @@ float ppmCH4 = MQ4.readSensor();
 * AO -> Analog Output of the sensor
 ##### Data of board that you should have
 * RL Value in KOhms
+* If the sensor uses a different supply voltage than the ADC reference, call `yourSensor.setVCC(<voltage>);`
 ##### Graph
 ![Wiring_MQSensor](https://raw.githubusercontent.com/miguel5612/MQSensorsLib_Docs/master/static/img/Points_explanation.jpeg)
 #### RS/R0 value (From datasheet of your sensor)
@@ -121,15 +122,15 @@ You'll need Arduino desktop app 1.8.9 or later.
 ### Sensor manufacturers:
 | Sensor | Manufacture | URL Datasheet |
 |----------|----------|----------|
-| MQ-2 | Pololulu| [datasheet](https://www.pololu.com/file/0J309/MQ2.pdf) |
+| MQ-2 | HANWEI Electronics| [datasheet](https://www.pololu.com/file/0J309/MQ2.pdf) |
-| MQ-3 | Sparkfun | [datasheet](https://www.sparkfun.com/datasheets/Sensors/MQ-3.pdf) |
+| MQ-3 | HANWEI Electronics | [datasheet](https://www.sparkfun.com/datasheets/Sensors/MQ-3.pdf) |
-| MQ-4 | Sparkfun | [datasheet](https://www.sparkfun.com/datasheets/Sensors/Biometric/MQ-4.pdf) |
+| MQ-4 | HANWEI Electronics | [datasheet](https://www.sparkfun.com/datasheets/Sensors/Biometric/MQ-4.pdf) |
-| MQ-5 | parallax | [datasheet](https://www.parallax.com/sites/default/files/downloads/605-00009-MQ-5-Datasheet.pdf) |
+| MQ-5 | HANWEI Electronics | [datasheet](https://www.parallax.com/sites/default/files/downloads/605-00009-MQ-5-Datasheet.pdf) |
-| MQ-6 | Sparkfun | [datasheet](https://www.sparkfun.com/datasheets/Sensors/Biometric/MQ-6.pdf) |
+| MQ-6 | HANWEI Electronics | [datasheet](https://www.sparkfun.com/datasheets/Sensors/Biometric/MQ-6.pdf) |
-| MQ-7 | Sparkfun | [datasheet](https://www.sparkfun.com/datasheets/Sensors/Biometric/MQ-7.pdf) |
+| MQ-7 | HANWEI Electronics | [datasheet](https://www.sparkfun.com/datasheets/Sensors/Biometric/MQ-7.pdf) |
-| MQ-8 | Sparkfun | [datasheet](https://dlnmh9ip6v2uc.cloudfront.net/datasheets/Sensors/Biometric/MQ-8.pdf) |
+| MQ-8 | HANWEI Electronics | [datasheet](https://dlnmh9ip6v2uc.cloudfront.net/datasheets/Sensors/Biometric/MQ-8.pdf) |
-| MQ-9 | Haoyuelectronics | [datasheet](http://www.haoyuelectronics.com/Attachment/MQ-9/MQ9.pdf) |
+| MQ-9 | HANWEI Electronics | [datasheet](http://www.haoyuelectronics.com/Attachment/MQ-9/MQ9.pdf) |
-| MQ-131 | Sensorsportal | [datasheet](http://www.sensorsportal.com/DOWNLOADS/MQ131.pdf) |
+| MQ-131 | HANWEI Electronics | [datasheet](http://www.sensorsportal.com/DOWNLOADS/MQ131.pdf) |
 | MQ-135 | HANWEI Electronics | [datasheet](https://www.electronicoscaldas.com/datasheet/MQ-135_Hanwei.pdf) |
 | MQ-136 | HANWEI Electronics | [datasheet](https://github.com/miguel5612/MQSensorsLib_Docs/blob/master/Datasheets/MQ136%20-%20Hanwei.pdf) |
 | MQ-303A | HANWEI Electronics | [datasheet](http://www.kosmodrom.com.ua/pdf/MQ303A.pdf) |
@@ -173,6 +174,10 @@ Examples/MQ-board.ino
 * [Data sheets](https://github.com/miguel5612/MQSensorsLib_Docs/tree/master/Datasheets) - Curves and behavior for each sensor, using logarithmic graphs.
 * [Main purpose](https://github.com/miguel5612/MQSensorsLib_Docs/blob/master/static/img/bg.jpg) - Every sensor has high sensibility for a specific gas or material.
 
+## Issues
+
+Consulte [docs/issues.md](docs/issues.md) para un resumen de los problemas abiertos y sus soluciones.
+
 ## Contributing
 
 Please read [CONTRIBUTING.md](https://github.com/miguel5612/MQSensorsLib/blob/master/CONTRIBUTING.md) for details on our code of conduct, and the process for submitting pull requests to us.

docs/issues.md

@@ -0,0 +1,33 @@
+# Issues y soluciones
+
+Este documento resume los problemas reportados en el repositorio y las soluciones propuestas o implementadas.
+
+## Abiertos
+
+### #75 MQ-3 sensor and CH4 gas reading 'ovf' failure
+**Estado:** resuelto en la rama `main`
+
+El usuario reporta desbordamiento ("ovf") al utilizar valores muy altos en `setA` y `setB` para leer CH4 con un sensor MQ-3. La solución propuesta es revisar los valores utilizados en `setA` y `setB`, ya que `2*10^31` en C++ no corresponde a `2e31`. Se recomienda usar notación exponencial (`2e31`) o `pow(10,31)` y comprobar que los parámetros no excedan el rango de `float`.
+
+**Actualización:** se añadieron validaciones de entrada, predicción de desbordamiento mediante logaritmos y verificación del resultado final para evitar valores "ovf" incluso con coeficientes muy altos. Las nuevas funciones limitan `setA` y `setB` y emplean cálculos en doble precisión.
+
+### #74 possible error in the calculation formula for `_RS_Calc`
+**Estado:** resuelto en la rama `work`
+
+Se detectó que la resistencia del sensor se calculaba con `_VOLT_RESOLUTION` en lugar del voltaje de alimentación real. Se añadieron los métodos `setVCC` y `getVCC` y se modificaron las ecuaciones para usar `VCC`. Esta corrección se refleja en la versión 3.0.1 de la biblioteca.
+
+### #70 Parameters to model temperature and humidity dependence
+**Estado:** resuelto en la rama `work`
+
+Se añadieron variables opcionales de "correction factor" en todos los ejemplos y se extendieron las funciones `calibrate` y `readSensorR0Rs` para aceptar este parámetro opcional. Así, el usuario puede ajustar las lecturas en función de temperatura y humedad cuando el datasheet lo permita. Los coeficientes deben consultarse para cada sensor.
+
+### #67 Sensor won't finish the Calibration process if done in clean air
+**Estado:** abierto
+
+Se reporta que la calibración se detiene mostrando un mensaje de "Conection issue" cuando se intenta calibrar el sensor MQ-135 en aire limpio. La recomendación del mantenedor es revisar la conexión física y probar el sensor con un programa básico para asegurar su correcto funcionamiento antes de usar la librería. Aún no se ha implementado un cambio en el código.
+
+
+## Cerrados destacados
+
+Para obtener más información sobre todos los issues cerrados, consulte la página de [Issues en GitHub](https://github.com/miguel5612/MQSensorsLib/issues?q=is%3Aissue+is%3Aclosed).
+

examples/Alcoholimeter/Alcoholimeter.ino

@@ -66,7 +66,7 @@ void setup() {
   // Explanation: 
    // In this routine the sensor will measure the resistance of the sensor supposedly before being pre-heated
   // and on clean air (Calibration conditions), setting up R0 value.
-  // We recomend executing this routine only on setup in laboratory conditions.
+  // We recommend executing this routine only on setup in laboratory conditions.
   // This routine does not need to be executed on each restart, you can load your R0 value from eeprom.
   // Acknowledgements: https://jayconsystems.com/blog/understanding-a-gas-sensor
   Serial.print("Calibrating please wait.");
@@ -80,14 +80,15 @@ void setup() {
   MQ3.setR0(calcR0/10);
   Serial.println("  done!.");
   
-  if(isinf(calcR0)) {Serial.println("Warning: Conection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
+  if(isinf(calcR0)) {Serial.println("Warning: Connection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
-  if(calcR0 == 0){Serial.println("Warning: Conection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
+  if(calcR0 == 0){Serial.println("Warning: Connection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
   /*****************************  MQ CAlibration ********************************************/  
 }
 
 void loop() {
   MQ3.update(); // Update data, the arduino will read the voltage from the analog pin
-  alcoholPPM = MQ3.readSensor(); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
+  float correctionFactor = 0; // Optional environmental correction
+  alcoholPPM = MQ3.readSensor(false, correctionFactor); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
   Serial.print("Alcohol now (PPM): ");
   Serial.println(alcoholPPM);
   delay(500); //Sampling frequency

examples/ESP32/ESP32.ino

@@ -65,7 +65,7 @@ void setup() {
   // Explanation: 
    // In this routine the sensor will measure the resistance of the sensor supposedly before being pre-heated
   // and on clean air (Calibration conditions), setting up R0 value.
-  // We recomend executing this routine only on setup in laboratory conditions.
+  // We recommend executing this routine only on setup in laboratory conditions.
   // This routine does not need to be executed on each restart, you can load your R0 value from eeprom.
   // Acknowledgements: https://jayconsystems.com/blog/understanding-a-gas-sensor
   Serial.print("Calibrating please wait.");
@@ -79,15 +79,16 @@ void setup() {
   MQ3.setR0(calcR0/10);
   Serial.println("  done!.");
   
-  if(isinf(calcR0)) {Serial.println("Warning: Conection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
+  if(isinf(calcR0)) {Serial.println("Warning: Connection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
-  if(calcR0 == 0){Serial.println("Warning: Conection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
+  if(calcR0 == 0){Serial.println("Warning: Connection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
   /*****************************  MQ CAlibration ********************************************/ 
   MQ3.serialDebug(true);
 }
 
 void loop() {
   MQ3.update(); // Update data, the arduino will read the voltage from the analog pin
-  MQ3.readSensor(); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
+  float correctionFactor = 0; // Optional environmental correction
+  MQ3.readSensor(false, correctionFactor); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
   MQ3.serialDebug(); // Will print the table on the serial port
   delay(500); //Sampling frequency
 }

examples/ESP32/ESP32_WROOM_32D/ESP32_WROOM_32D.ino

@@ -86,7 +86,7 @@ void setup()
   // Explanation: 
    // In this routine the sensor will measure the resistance of the sensor supposedly before being pre-heated
   // and on clean air (Calibration conditions), setting up R0 value.
-  // We recomend executing this routine only on setup in laboratory conditions.
+  // We recommend executing this routine only on setup in laboratory conditions.
   // This routine does not need to be executed on each restart, you can load your R0 value from eeprom.
   // Acknowledgements: https://jayconsystems.com/blog/understanding-a-gas-sensor
   Serial.print("Calibrating please wait.");
@@ -100,8 +100,8 @@ void setup()
   MQ2.setR0(calcR0/10);
   Serial.println("  done!.");
   
-  if(isinf(calcR0)) {Serial.println("Warning: Conection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
+  if(isinf(calcR0)) {Serial.println("Warning: Connection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
-  if(calcR0 == 0){Serial.println("Warning: Conection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
+  if(calcR0 == 0){Serial.println("Warning: Connection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
   /*****************************  MQ CAlibration ********************************************/ 
   //MQ2.serialDebug(true); uncomment if you want to print the table on the serial port
 
@@ -129,7 +129,8 @@ void loop()
 {
   MQ2.update(); // Update data, the arduino will read the voltage from the analog pin
   //MQ2.serialDebug(); // Will print the table on the serial port
-  Serial.print(MQ2.readSensor()); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
+  float correctionFactor = 0; // Optional environmental correction
+  Serial.print(MQ2.readSensor(false, correctionFactor)); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
   Serial.println(" PPM");
   delay(500); //Sampling frequency
 }

examples/ESP8266/ESP8266.ino

@@ -65,7 +65,7 @@ void setup() {
   // Explanation: 
    // In this routine the sensor will measure the resistance of the sensor supposedly before being pre-heated
   // and on clean air (Calibration conditions), setting up R0 value.
-  // We recomend executing this routine only on setup in laboratory conditions.
+  // We recommend executing this routine only on setup in laboratory conditions.
   // This routine does not need to be executed on each restart, you can load your R0 value from eeprom.
   // Acknowledgements: https://jayconsystems.com/blog/understanding-a-gas-sensor
   Serial.print("Calibrating please wait.");
@@ -79,15 +79,16 @@ void setup() {
   MQ3.setR0(calcR0/10);
   Serial.println("  done!.");
   
-  if(isinf(calcR0)) {Serial.println("Warning: Conection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
+  if(isinf(calcR0)) {Serial.println("Warning: Connection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
-  if(calcR0 == 0){Serial.println("Warning: Conection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
+  if(calcR0 == 0){Serial.println("Warning: Connection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
   /*****************************  MQ CAlibration ********************************************/ 
   MQ3.serialDebug(true);
 }
 
 void loop() {
   MQ3.update(); // Update data, the arduino will read the voltage from the analog pin
-  MQ3.readSensor(); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
+  float correctionFactor = 0; // Optional environmental correction
+  MQ3.readSensor(false, correctionFactor); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
   MQ3.serialDebug(); // Will print the table on the serial port
   delay(500); //Sampling frequency
 }

examples/LinearVsExponential/LinearVsExponential.ino

@@ -45,7 +45,7 @@ void setup() {
   // Explanation: 
    // In this routine the sensor will measure the resistance of the sensor supposedly before being pre-heated
   // and on clean air (Calibration conditions), setting up R0 value.
-  // We recomend executing this routine only on setup in laboratory conditions.
+  // We recommend executing this routine only on setup in laboratory conditions.
   // This routine does not need to be executed on each restart, you can load your R0 value from eeprom.
   // Acknowledgements: https://jayconsystems.com/blog/understanding-a-gas-sensor
   Serial.print("Calibrating please wait.");
@@ -59,8 +59,8 @@ void setup() {
   MQ4.setR0(calcR0/10);
   Serial.println("  done!.");
   
-  if(isinf(calcR0)) {Serial.println("Warning: Conection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
+  if(isinf(calcR0)) {Serial.println("Warning: Connection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
-  if(calcR0 == 0){Serial.println("Warning: Conection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
+  if(calcR0 == 0){Serial.println("Warning: Connection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
   /*****************************  MQ CAlibration ********************************************/ 
 
   /* 
@@ -81,17 +81,18 @@ void setup() {
 
 void loop() {
   MQ4.update(); // Update data, the arduino will read the voltage from the analog pin
+  float correctionFactor = 0; // Optional environmental correction
   
   //https://jayconsystems.com/blog/understanding-a-gas-sensor 
   //Set math model to calculate the PPM concentration and the value of constants
   MQ4.setRegressionMethod(0); //_PPM =  pow(10, (log10(ratio)-b)/a)
   MQ4.setA(-0.318); MQ4.setB(1.133); // A -> Slope, B -> Intersect with X - Axis
-  float LPG1 = MQ4.readSensor(); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
+  float LPG1 = MQ4.readSensor(false, correctionFactor); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
   
   //Set math model to calculate the PPM concentration and the value of constants
   MQ4.setRegressionMethod(1); //_PPM =  a*ratio^b
   MQ4.setA(1012.7); MQ4.setB(-2.786); // Configure the equation to to calculate CH4 concentration
-  float LPG2 = MQ4.readSensor(); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
+  float LPG2 = MQ4.readSensor(false, correctionFactor); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
 
   //  exposure to 2000 ppm of LPG gas is immediately dangerous to life and health. In this section
   if(LPG1>=2000 || LPG2>=2000) Serial.println("Warning - Very high concentrations detected!");

examples/MQ-131/MQ-131.ino

@@ -67,7 +67,7 @@ void setup() {
   // Explanation: 
    // In this routine the sensor will measure the resistance of the sensor supposedly before being pre-heated
   // and on clean air (Calibration conditions), setting up R0 value.
-  // We recomend executing this routine only on setup in laboratory conditions.
+  // We recommend executing this routine only on setup in laboratory conditions.
   // This routine does not need to be executed on each restart, you can load your R0 value from eeprom.
   // Acknowledgements: https://jayconsystems.com/blog/understanding-a-gas-sensor
   Serial.print("Calibrating please wait.");
@@ -81,8 +81,8 @@ void setup() {
   MQ131.setR0(calcR0/10);
   Serial.println("  done!.");
   
-  if(isinf(calcR0)) {Serial.println("Warning: Conection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
+  if(isinf(calcR0)) {Serial.println("Warning: Connection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
-  if(calcR0 == 0){Serial.println("Warning: Conection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
+  if(calcR0 == 0){Serial.println("Warning: Connection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
   /*****************************  MQ CAlibration ********************************************/ 
   MQ131.serialDebug(true);
   Serial.println("Ignore Ratio = RS/R0, for this example we will use readSensorR0Rs, the ratio calculated will be R0/Rs. Thanks :)");

examples/MQ-135-ALL/MQ-135-ALL.ino

@@ -55,7 +55,7 @@ void setup() {
   // Explanation: 
   // In this routine the sensor will measure the resistance of the sensor supposedly before being pre-heated
   // and on clean air (Calibration conditions), setting up R0 value.
-  // We recomend executing this routine only on setup in laboratory conditions.
+  // We recommend executing this routine only on setup in laboratory conditions.
   // This routine does not need to be executed on each restart, you can load your R0 value from eeprom.
   // Acknowledgements: https://jayconsystems.com/blog/understanding-a-gas-sensor
   Serial.print("Calibrating please wait.");
@@ -69,8 +69,8 @@ void setup() {
   MQ135.setR0(calcR0/10);
   Serial.println("  done!.");
   
-  if(isinf(calcR0)) {Serial.println("Warning: Conection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
+  if(isinf(calcR0)) {Serial.println("Warning: Connection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
-  if(calcR0 == 0){Serial.println("Warning: Conection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
+  if(calcR0 == 0){Serial.println("Warning: Connection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
   /*****************************  MQ CAlibration ********************************************/ 
   Serial.println("** Values from MQ-135 ****");
   Serial.println("|    CO   |  Alcohol |   CO2  |  Toluen  |  NH4  |  Aceton  |");  
@@ -78,24 +78,25 @@ void setup() {
 
 void loop() {
   MQ135.update(); // Update data, the arduino will read the voltage from the analog pin
+  float correctionFactor = 0; // Optional environmental correction
 
   MQ135.setA(605.18); MQ135.setB(-3.937); // Configure the equation to calculate CO concentration value
-  float CO = MQ135.readSensor(); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
+  float CO = MQ135.readSensor(false, correctionFactor); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
 
   MQ135.setA(77.255); MQ135.setB(-3.18); //Configure the equation to calculate Alcohol concentration value
-  float Alcohol = MQ135.readSensor(); // SSensor will read PPM concentration using the model, a and b values set previously or from the setup
+  float Alcohol = MQ135.readSensor(false, correctionFactor); // SSensor will read PPM concentration using the model, a and b values set previously or from the setup
 
   MQ135.setA(110.47); MQ135.setB(-2.862); // Configure the equation to calculate CO2 concentration value
-  float CO2 = MQ135.readSensor(); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
+  float CO2 = MQ135.readSensor(false, correctionFactor); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
 
   MQ135.setA(44.947); MQ135.setB(-3.445); // Configure the equation to calculate Toluen concentration value
-  float Toluen = MQ135.readSensor(); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
+  float Toluen = MQ135.readSensor(false, correctionFactor); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
   
   MQ135.setA(102.2 ); MQ135.setB(-2.473); // Configure the equation to calculate NH4 concentration value
-  float NH4 = MQ135.readSensor(); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
+  float NH4 = MQ135.readSensor(false, correctionFactor); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
 
   MQ135.setA(34.668); MQ135.setB(-3.369); // Configure the equation to calculate Aceton concentration value
-  float Aceton = MQ135.readSensor(); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
+  float Aceton = MQ135.readSensor(false, correctionFactor); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
   Serial.print("|   "); Serial.print(CO); 
   Serial.print("   |   "); Serial.print(Alcohol);
   // Note: 400 Offset for CO2 source: https://github.com/miguel5612/MQSensorsLib/issues/29

examples/MQ-135-CorrectionFactorDHT11/MQ-135-CorrectionFactorDHT11.ino

@@ -106,7 +106,7 @@ void setup() {
   // Explanation: 
    // In this routine the sensor will measure the resistance of the sensor supposedly before being pre-heated
   // and on clean air (Calibration conditions), setting up R0 value.
-  // We recomend executing this routine only on setup in laboratory conditions.
+  // We recommend executing this routine only on setup in laboratory conditions.
   // This routine does not need to be executed on each restart, you can load your R0 value from eeprom.
   // Acknowledgements: https://jayconsystems.com/blog/understanding-a-gas-sensor
   Serial.print("Calibrating please wait.");
@@ -120,8 +120,8 @@ void setup() {
   MQ135.setR0(calcR0/10);
   Serial.println("  done!.");
   
-  if(isinf(calcR0)) {Serial.println("Warning: Conection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
+  if(isinf(calcR0)) {Serial.println("Warning: Connection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
-  if(calcR0 == 0){Serial.println("Warning: Conection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
+  if(calcR0 == 0){Serial.println("Warning: Connection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
   /*****************************  MQ CAlibration ********************************************/ 
   MQ135.serialDebug(true);
   // Set delay between sensor readings based on sensor details.

examples/MQ-135/MQ-135.ino

@@ -67,7 +67,7 @@ void setup() {
   // Explanation: 
    // In this routine the sensor will measure the resistance of the sensor supposedly before being pre-heated
   // and on clean air (Calibration conditions), setting up R0 value.
-  // We recomend executing this routine only on setup in laboratory conditions.
+  // We recommend executing this routine only on setup in laboratory conditions.
   // This routine does not need to be executed on each restart, you can load your R0 value from eeprom.
   // Acknowledgements: https://jayconsystems.com/blog/understanding-a-gas-sensor
   Serial.print("Calibrating please wait.");
@@ -81,15 +81,16 @@ void setup() {
   MQ135.setR0(calcR0/10);
   Serial.println("  done!.");
   
-  if(isinf(calcR0)) {Serial.println("Warning: Conection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
+  if(isinf(calcR0)) {Serial.println("Warning: Connection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
-  if(calcR0 == 0){Serial.println("Warning: Conection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
+  if(calcR0 == 0){Serial.println("Warning: Connection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
   /*****************************  MQ CAlibration ********************************************/ 
   MQ135.serialDebug(true);
 }
 
 void loop() {
   MQ135.update(); // Update data, the arduino will read the voltage from the analog pin
-  MQ135.readSensor(); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
+  float correctionFactor = 0; // Optional environmental correction
+  MQ135.readSensor(false, correctionFactor); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
   MQ135.serialDebug(); // Will print the table on the serial port
   delay(500); //Sampling frequency
 }

examples/MQ-136/MQ-136.ino

@@ -60,7 +60,7 @@ void setup() {
   // Explanation: 
    // In this routine the sensor will measure the resistance of the sensor supposedly before being pre-heated
   // and on clean air (Calibration conditions), setting up R0 value.
-  // We recomend executing this routine only on setup in laboratory conditions.
+  // We recommend executing this routine only on setup in laboratory conditions.
   // This routine does not need to be executed on each restart, you can load your R0 value from eeprom.
   // Acknowledgements: https://jayconsystems.com/blog/understanding-a-gas-sensor
   Serial.print("Calibrating please wait.");
@@ -74,15 +74,16 @@ void setup() {
   MQ136.setR0(calcR0/10);
   Serial.println("  done!.");
   
-  if(isinf(calcR0)) {Serial.println("Warning: Conection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
+  if(isinf(calcR0)) {Serial.println("Warning: Connection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
-  if(calcR0 == 0){Serial.println("Warning: Conection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
+  if(calcR0 == 0){Serial.println("Warning: Connection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
   /*****************************  MQ CAlibration ********************************************/ 
   MQ136.serialDebug(true);
 }
 
 void loop() {
   MQ136.update(); // Update data, the arduino will read the voltage from the analog pin
-  MQ136.readSensor(); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
+  float correctionFactor = 0; // Optional environmental correction
+  MQ136.readSensor(false, correctionFactor); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
   MQ136.serialDebug(); // Will print the table on the serial port
   delay(500); //Sampling frequency
 }

examples/MQ-2/MQ-2.ino

@@ -64,7 +64,7 @@ void setup() {
   // Explanation: 
    // In this routine the sensor will measure the resistance of the sensor supposedly before being pre-heated
   // and on clean air (Calibration conditions), setting up R0 value.
-  // We recomend executing this routine only on setup in laboratory conditions.
+  // We recommend executing this routine only on setup in laboratory conditions.
   // This routine does not need to be executed on each restart, you can load your R0 value from eeprom.
   // Acknowledgements: https://jayconsystems.com/blog/understanding-a-gas-sensor
   Serial.print("Calibrating please wait.");
@@ -78,8 +78,8 @@ void setup() {
   MQ2.setR0(calcR0/10);
   Serial.println("  done!.");
   
-  if(isinf(calcR0)) {Serial.println("Warning: Conection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
+  if(isinf(calcR0)) {Serial.println("Warning: Connection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
-  if(calcR0 == 0){Serial.println("Warning: Conection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
+  if(calcR0 == 0){Serial.println("Warning: Connection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
   /*****************************  MQ CAlibration ********************************************/ 
 
   MQ2.serialDebug(true);
@@ -87,7 +87,8 @@ void setup() {
 
 void loop() {
   MQ2.update(); // Update data, the arduino will read the voltage from the analog pin
-  MQ2.readSensor(); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
+  float correctionFactor = 0; // Optional environmental correction
+  MQ2.readSensor(false, correctionFactor); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
   MQ2.serialDebug(); // Will print the table on the serial port
   delay(500); //Sampling frequency
 }

examples/MQ-3/MQ-3.ino

@@ -66,7 +66,7 @@ void setup() {
   // Explanation: 
    // In this routine the sensor will measure the resistance of the sensor supposedly before being pre-heated
   // and on clean air (Calibration conditions), setting up R0 value.
-  // We recomend executing this routine only on setup in laboratory conditions.
+  // We recommend executing this routine only on setup in laboratory conditions.
   // This routine does not need to be executed on each restart, you can load your R0 value from eeprom.
   // Acknowledgements: https://jayconsystems.com/blog/understanding-a-gas-sensor
   Serial.print("Calibrating please wait.");
@@ -80,15 +80,16 @@ void setup() {
   MQ3.setR0(calcR0/10);
   Serial.println("  done!.");
   
-  if(isinf(calcR0)) {Serial.println("Warning: Conection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
+  if(isinf(calcR0)) {Serial.println("Warning: Connection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
-  if(calcR0 == 0){Serial.println("Warning: Conection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
+  if(calcR0 == 0){Serial.println("Warning: Connection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
   /*****************************  MQ CAlibration ********************************************/ 
   MQ3.serialDebug(true);
 }
 
 void loop() {
   MQ3.update(); // Update data, the arduino will read the voltage from the analog pin
-  MQ3.readSensor(); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
+  float correctionFactor = 0; // Optional environmental correction
+  MQ3.readSensor(false, correctionFactor); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
   MQ3.serialDebug(); // Will print the table on the serial port
   delay(500); //Sampling frequency
 }

examples/MQ-303A/MQ-303A.ino

@@ -64,7 +64,7 @@ void setup() {
   // Explanation: 
    // In this routine the sensor will measure the resistance of the sensor supposedly before being pre-heated
   // and on clean air (Calibration conditions), setting up R0 value.
-  // We recomend executing this routine only on setup in laboratory conditions.
+  // We recommend executing this routine only on setup in laboratory conditions.
   // This routine does not need to be executed on each restart, you can load your R0 value from eeprom.
   // Acknowledgements: https://jayconsystems.com/blog/understanding-a-gas-sensor
   Serial.print("Calibrating please wait.");
@@ -78,15 +78,16 @@ void setup() {
   MQ303.setR0(calcR0/10);
   Serial.println("  done!.");
   
-  if(isinf(calcR0)) {Serial.println("Warning: Conection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
+  if(isinf(calcR0)) {Serial.println("Warning: Connection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
-  if(calcR0 == 0){Serial.println("Warning: Conection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
+  if(calcR0 == 0){Serial.println("Warning: Connection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
   /*****************************  MQ CAlibration ********************************************/ 
   MQ303.serialDebug(true);
 }
 
 void loop() {
   MQ303.update(); // Update data, the arduino will read the voltage from the analog pin
-  MQ303.readSensor(true); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
+  float correctionFactor = 0; // Optional environmental correction
+  MQ303.readSensor(true, correctionFactor); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
   MQ303.serialDebug(); // Will print the table on the serial port
   delay(500); //Sampling frequency
 }

examples/MQ-309A/MQ-309A.ino

@@ -67,7 +67,7 @@ void setup() {
   // Explanation: 
    // In this routine the sensor will measure the resistance of the sensor supposedly before being pre-heated
   // and on clean air (Calibration conditions), setting up R0 value.
-  // We recomend executing this routine only on setup in laboratory conditions.
+  // We recommend executing this routine only on setup in laboratory conditions.
   // This routine does not need to be executed on each restart, you can load your R0 value from eeprom.
   // Acknowledgements: https://jayconsystems.com/blog/understanding-a-gas-sensor
   Serial.print("Calibrating please wait.");
@@ -81,8 +81,8 @@ void setup() {
   MQ309.setR0(calcR0/10);
   Serial.println("  done!.");
   
-  if(isinf(calcR0)) {Serial.println("Warning: Conection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
+  if(isinf(calcR0)) {Serial.println("Warning: Connection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
-  if(calcR0 == 0){Serial.println("Warning: Conection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
+  if(calcR0 == 0){Serial.println("Warning: Connection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
   /*****************************  MQ CAlibration ********************************************/ 
   MQ309.serialDebug(true);
 }
@@ -95,7 +95,8 @@ void loop() {
     // VH 0.9 Volts
     analogWrite(5, 2); // 255 is 100%, 2.295 is aprox 0.9% of Duty cycle for 60s
     MQ309.update(); // Update data, the arduino will read the voltage from the analog pin
-    MQ309.readSensor(); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
+    float correctionFactor = 0; // Optional environmental correction
+    MQ309.readSensor(false, correctionFactor); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
     MQ309.serialDebug(); // Will print the table on the serial port
     delay(500); //Sampling frequency
   }
@@ -107,7 +108,8 @@ void loop() {
     // VL 0.2 Volts
     analogWrite(5, 1); // 255 is 100%, 0.51 is aprox 0.2% of Duty cycle for 120s
     MQ309.update(); // Update data, the arduino will read the voltage from the analog pin
-    MQ309.readSensor(); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
+    float correctionFactor2 = 0; // Optional environmental correction
+    MQ309.readSensor(false, correctionFactor2); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
     MQ309.serialDebug(); // Will print the table on the serial port
     delay(500); //Sampling frequency
   } 

examples/MQ-4-ALL/MQ-4-ALL.ino

@@ -55,7 +55,7 @@ void setup() {
   // Explanation: 
    // In this routine the sensor will measure the resistance of the sensor supposedly before being pre-heated
   // and on clean air (Calibration conditions), setting up R0 value.
-  // We recomend executing this routine only on setup in laboratory conditions.
+  // We recommend executing this routine only on setup in laboratory conditions.
   // This routine does not need to be executed on each restart, you can load your R0 value from eeprom.
   // Acknowledgements: https://jayconsystems.com/blog/understanding-a-gas-sensor
   Serial.print("Calibrating please wait.");
@@ -69,8 +69,8 @@ void setup() {
   MQ4.setR0(calcR0/10);
   Serial.println("  done!.");
   
-  if(isinf(calcR0)) {Serial.println("Warning: Conection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
+  if(isinf(calcR0)) {Serial.println("Warning: Connection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
-  if(calcR0 == 0){Serial.println("Warning: Conection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
+  if(calcR0 == 0){Serial.println("Warning: Connection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
   /*****************************  MQ CAlibration ********************************************/ 
 
   Serial.println("*************** Values from MQ-4 **********************");
@@ -79,6 +79,7 @@ void setup() {
 
 void loop() {
   MQ4.update(); // Update data, the arduino will read the voltage from the analog pin
+  float correctionFactor = 0; // Optional environmental correction
   
   /*
     Exponential regression:
@@ -90,19 +91,19 @@ void loop() {
   smoke  | 30000000 | -8.308
   */
   MQ4.setA(3811.9); MQ4.setB(-3.113); // Configure the equation to to calculate CH4 concentration
-  float LPG = MQ4.readSensor(); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
+  float LPG = MQ4.readSensor(false, correctionFactor); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
   
   MQ4.setA(1012.7); MQ4.setB(-2.786); // Configure the equation to to calculate CH4 concentration
-  float CH4 = MQ4.readSensor(); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
+  float CH4 = MQ4.readSensor(false, correctionFactor); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
   
   MQ4.setA(200000000000000); MQ4.setB(-19.05); // Configure the equation to to calculate CH4 concentration
-  float CO = MQ4.readSensor(); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
+  float CO = MQ4.readSensor(false, correctionFactor); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
   
   MQ4.setA(60000000000); MQ4.setB(-14.01); // Configure the equation to to calculate CH4 concentration
-  float Alcohol = MQ4.readSensor(); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
+  float Alcohol = MQ4.readSensor(false, correctionFactor); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
   
   MQ4.setA(30000000); MQ4.setB(-8.308); // Configure the equation to to calculate CH4 concentration
-  float Smoke = MQ4.readSensor(); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
+  float Smoke = MQ4.readSensor(false, correctionFactor); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
   
   Serial.print("|    "); Serial.print(LPG);
   Serial.print("    |    "); Serial.print(CH4);

examples/MQ-4-LINEAR/MQ-4-LINEAR.ino

@@ -54,7 +54,7 @@ void setup() {
   // Explanation: 
    // In this routine the sensor will measure the resistance of the sensor supposedly before being pre-heated
   // and on clean air (Calibration conditions), setting up R0 value.
-  // We recomend executing this routine only on setup in laboratory conditions.
+  // We recommend executing this routine only on setup in laboratory conditions.
   // This routine does not need to be executed on each restart, you can load your R0 value from eeprom.
   // Acknowledgements: https://jayconsystems.com/blog/understanding-a-gas-sensor
   Serial.print("Calibrating please wait.");
@@ -68,8 +68,8 @@ void setup() {
   MQ4.setR0(calcR0/10);
   Serial.println("  done!.");
   
-  if(isinf(calcR0)) {Serial.println("Warning: Conection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
+  if(isinf(calcR0)) {Serial.println("Warning: Connection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
-  if(calcR0 == 0){Serial.println("Warning: Conection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
+  if(calcR0 == 0){Serial.println("Warning: Connection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
   /*****************************  MQ CAlibration ********************************************/ 
 
   Serial.println("** Values from MQ-4**********");
@@ -81,7 +81,8 @@ void loop() {
   
   //https://jayconsystems.com/blog/understanding-a-gas-sensor 
   MQ4.setA(-0.318); MQ4.setB(1.133); // A -> Slope, B -> Intersect with X - Axis
-  float LPG = MQ4.readSensor(); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
+  float correctionFactor = 0; // Optional environmental correction
+  float LPG = MQ4.readSensor(false, correctionFactor); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
 
   //  exposure to 2000 ppm of LPG gas is immediately dangerous to life and health. In this section
   if(LPG>=2000) Serial.println("Warning - Very high concentrations detected!");

examples/MQ-4/MQ-4.ino

@@ -65,7 +65,7 @@ void setup() {
   // Explanation: 
    // In this routine the sensor will measure the resistance of the sensor supposedly before being pre-heated
   // and on clean air (Calibration conditions), setting up R0 value.
-  // We recomend executing this routine only on setup in laboratory conditions.
+  // We recommend executing this routine only on setup in laboratory conditions.
   // This routine does not need to be executed on each restart, you can load your R0 value from eeprom.
   // Acknowledgements: https://jayconsystems.com/blog/understanding-a-gas-sensor
   Serial.print("Calibrating please wait.");
@@ -79,15 +79,16 @@ void setup() {
   MQ4.setR0(calcR0/10);
   Serial.println("  done!.");
   
-  if(isinf(calcR0)) {Serial.println("Warning: Conection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
+  if(isinf(calcR0)) {Serial.println("Warning: Connection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
-  if(calcR0 == 0){Serial.println("Warning: Conection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
+  if(calcR0 == 0){Serial.println("Warning: Connection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
   /*****************************  MQ CAlibration ********************************************/ 
   MQ4.serialDebug(true);
 }
 
 void loop() {
   MQ4.update(); // Update data, the arduino will read the voltage from the analog pin
-  MQ4.readSensor(); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
+  float correctionFactor = 0; // Optional environmental correction
+  MQ4.readSensor(false, correctionFactor); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
   MQ4.serialDebug(); // Will print the table on the serial port
   delay(500); //Sampling frequency
 }

examples/MQ-5/MQ-5.ino

@@ -65,7 +65,7 @@ void setup() {
   // Explanation: 
    // In this routine the sensor will measure the resistance of the sensor supposedly before being pre-heated
   // and on clean air (Calibration conditions), setting up R0 value.
-  // We recomend executing this routine only on setup in laboratory conditions.
+  // We recommend executing this routine only on setup in laboratory conditions.
   // This routine does not need to be executed on each restart, you can load your R0 value from eeprom.
   // Acknowledgements: https://jayconsystems.com/blog/understanding-a-gas-sensor
   Serial.print("Calibrating please wait.");
@@ -79,15 +79,16 @@ void setup() {
   MQ5.setR0(calcR0/10);
   Serial.println("  done!.");
   
-  if(isinf(calcR0)) {Serial.println("Warning: Conection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
+  if(isinf(calcR0)) {Serial.println("Warning: Connection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
-  if(calcR0 == 0){Serial.println("Warning: Conection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
+  if(calcR0 == 0){Serial.println("Warning: Connection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
   /*****************************  MQ CAlibration ********************************************/ 
   MQ5.serialDebug(true);
 }
 
 void loop() {
   MQ5.update(); // Update data, the arduino will read the voltage from the analog pin
-  MQ5.readSensor(); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
+  float correctionFactor = 0; // Optional environmental correction
+  MQ5.readSensor(false, correctionFactor); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
   MQ5.serialDebug(); // Will print the table on the serial port
   delay(500); //Sampling frequency
 }

examples/MQ-6/MQ-6.ino

@@ -65,7 +65,7 @@ void setup() {
   // Explanation: 
    // In this routine the sensor will measure the resistance of the sensor supposedly before being pre-heated
   // and on clean air (Calibration conditions), setting up R0 value.
-  // We recomend executing this routine only on setup in laboratory conditions.
+  // We recommend executing this routine only on setup in laboratory conditions.
   // This routine does not need to be executed on each restart, you can load your R0 value from eeprom.
   // Acknowledgements: https://jayconsystems.com/blog/understanding-a-gas-sensor
   Serial.print("Calibrating please wait.");
@@ -79,15 +79,16 @@ void setup() {
   MQ6.setR0(calcR0/10);
   Serial.println("  done!.");
   
-  if(isinf(calcR0)) {Serial.println("Warning: Conection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
+  if(isinf(calcR0)) {Serial.println("Warning: Connection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
-  if(calcR0 == 0){Serial.println("Warning: Conection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
+  if(calcR0 == 0){Serial.println("Warning: Connection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
   /*****************************  MQ CAlibration ********************************************/ 
   MQ6.serialDebug(true);
 }
 
 void loop() {
   MQ6.update(); // Update data, the arduino will read the voltage from the analog pin
-  MQ6.readSensor(); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
+  float correctionFactor = 0; // Optional environmental correction
+  MQ6.readSensor(false, correctionFactor); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
   MQ6.serialDebug(); // Will print the table on the serial port
   delay(500); //Sampling frequency
 }

examples/MQ-7/MQ-7.ino

@@ -72,7 +72,7 @@ void setup() {
   // Explanation: 
    // In this routine the sensor will measure the resistance of the sensor supposedly before being pre-heated
   // and on clean air (Calibration conditions), setting up R0 value.
-  // We recomend executing this routine only on setup in laboratory conditions.
+  // We recommend executing this routine only on setup in laboratory conditions.
   // This routine does not need to be executed on each restart, you can load your R0 value from eeprom.
   // Acknowledgements: https://jayconsystems.com/blog/understanding-a-gas-sensor
   Serial.print("Calibrating please wait.");
@@ -86,8 +86,8 @@ void setup() {
   MQ7.setR0(calcR0/10);
   Serial.println("  done!.");
   
-  if(isinf(calcR0)) {Serial.println("Warning: Conection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
+  if(isinf(calcR0)) {Serial.println("Warning: Connection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
-  if(calcR0 == 0){Serial.println("Warning: Conection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
+  if(calcR0 == 0){Serial.println("Warning: Connection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
   /*****************************  MQ CAlibration ********************************************/ 
   MQ7.serialDebug(true);
 }
@@ -100,7 +100,8 @@ void loop() {
     // VH 5 Volts
     analogWrite(5, 255); // 255 is DC 5V output
     MQ7.update(); // Update data, the arduino will read the voltage from the analog pin
-    MQ7.readSensor(); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
+    float correctionFactor = 0; // Optional environmental correction
+    MQ7.readSensor(false, correctionFactor); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
     MQ7.serialDebug(); // Will print the table on the serial port
     delay(500); //Sampling frequency
   }
@@ -112,7 +113,8 @@ void loop() {
     // VH 1.4 Volts
     analogWrite(5, 20); // 255 is 100%, 20.4 is aprox 8% of Duty cycle for 90s
     MQ7.update(); // Update data, the arduino will read the voltage from the analog pin
-    MQ7.readSensor(); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
+    float correctionFactor2 = 0; // Optional environmental correction
+    MQ7.readSensor(false, correctionFactor2); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
     MQ7.serialDebug(); // Will print the table on the serial port
     delay(500); //Sampling frequency
   } 

examples/MQ-8/MQ-8.ino

@@ -66,7 +66,7 @@ void setup() {
   // Explanation: 
    // In this routine the sensor will measure the resistance of the sensor supposedly before being pre-heated
   // and on clean air (Calibration conditions), setting up R0 value.
-  // We recomend executing this routine only on setup in laboratory conditions.
+  // We recommend executing this routine only on setup in laboratory conditions.
   // This routine does not need to be executed on each restart, you can load your R0 value from eeprom.
   // Acknowledgements: https://jayconsystems.com/blog/understanding-a-gas-sensor
   Serial.print("Calibrating please wait.");
@@ -80,15 +80,16 @@ void setup() {
   MQ8.setR0(calcR0/10);
   Serial.println("  done!.");
   
-  if(isinf(calcR0)) {Serial.println("Warning: Conection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
+  if(isinf(calcR0)) {Serial.println("Warning: Connection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
-  if(calcR0 == 0){Serial.println("Warning: Conection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
+  if(calcR0 == 0){Serial.println("Warning: Connection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
   /*****************************  MQ CAlibration ********************************************/ 
   MQ8.serialDebug(true);
 }
 
 void loop() {
   MQ8.update(); // Update data, the arduino will read the voltage from the analog pin
-  MQ8.readSensor(); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
+  float correctionFactor = 0; // Optional environmental correction
+  MQ8.readSensor(false, correctionFactor); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
   MQ8.serialDebug(); // Will print the table on the serial port
   delay(500); //Sampling frequency
 }

examples/MQ-9-ALL/MQ-9-ALL.ino

@@ -55,7 +55,7 @@ void setup() {
   // Explanation: 
    // In this routine the sensor will measure the resistance of the sensor supposedly before being pre-heated
   // and on clean air (Calibration conditions), setting up R0 value.
-  // We recomend executing this routine only on setup in laboratory conditions.
+  // We recommend executing this routine only on setup in laboratory conditions.
   // This routine does not need to be executed on each restart, you can load your R0 value from eeprom.
   // Acknowledgements: https://jayconsystems.com/blog/understanding-a-gas-sensor
   Serial.print("Calibrating please wait.");
@@ -69,8 +69,8 @@ void setup() {
   MQ9.setR0(calcR0/10);
   Serial.println("  done!.");
   
-  if(isinf(calcR0)) {Serial.println("Warning: Conection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
+  if(isinf(calcR0)) {Serial.println("Warning: Connection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
-  if(calcR0 == 0){Serial.println("Warning: Conection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
+  if(calcR0 == 0){Serial.println("Warning: Connection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
   /*****************************  MQ CAlibration ********************************************/ 
   Serial.println("** Values from MQ-9 ****");
   Serial.println("|    LPG   |  CH4 |   CO  |");  
@@ -78,6 +78,7 @@ void setup() {
 
 void loop() {
   MQ9.update(); // Update data, the arduino will read the voltage from the analog pin
+  float correctionFactor = 0; // Optional environmental correction
   /*
   Exponential regression:
   GAS     | a      | b
@@ -87,13 +88,13 @@ void loop() {
   */
 
   MQ9.setA(1000.5); MQ9.setB(-2.186); // Configure the equation to to calculate LPG concentration
-  float LPG = MQ9.readSensor(); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
+  float LPG = MQ9.readSensor(false, correctionFactor); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
 
   MQ9.setA(4269.6); MQ9.setB(-2.648); // Configure the equation to to calculate LPG concentration
-  float CH4 = MQ9.readSensor(); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
+  float CH4 = MQ9.readSensor(false, correctionFactor); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
 
   MQ9.setA(599.65); MQ9.setB(-2.244); // Configure the equation to to calculate LPG concentration
-  float CO = MQ9.readSensor(); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
+  float CO = MQ9.readSensor(false, correctionFactor); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
 
   Serial.print("|    "); Serial.print(LPG);
   Serial.print("    |    "); Serial.print(CH4);

examples/MQ-9/MQ-9.ino

@@ -67,7 +67,7 @@ void setup() {
   // Explanation: 
    // In this routine the sensor will measure the resistance of the sensor supposedly before being pre-heated
   // and on clean air (Calibration conditions), setting up R0 value.
-  // We recomend executing this routine only on setup in laboratory conditions.
+  // We recommend executing this routine only on setup in laboratory conditions.
   // This routine does not need to be executed on each restart, you can load your R0 value from eeprom.
   // Acknowledgements: https://jayconsystems.com/blog/understanding-a-gas-sensor
   // ISSUE 44 - MQ9 needs a low/high temperature cycle like MQ7 #44
@@ -101,8 +101,8 @@ void setup() {
   MQ9.setR0(calcR0/10);
   Serial.println("  done!.");
   
-  if(isinf(calcR0)) {Serial.println("Warning: Conection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
+  if(isinf(calcR0)) {Serial.println("Warning: Connection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
-  if(calcR0 == 0){Serial.println("Warning: Conection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
+  if(calcR0 == 0){Serial.println("Warning: Connection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
   /*****************************  MQ CAlibration ********************************************/ 
   MQ9.serialDebug(true);
 }
@@ -115,7 +115,8 @@ void loop() {
   digitalWrite(PreaheatControlPin14, LOW);
   
   MQ9.update(); // Update data, the arduino will read the voltage from the analog pin
-  MQ9.readSensor(); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
+  float correctionFactor = 0; // Optional environmental correction
+  MQ9.readSensor(false, correctionFactor); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
   MQ9.serialDebug(); // Will print the table on the serial port
   
 }

examples/MQ-Board/MQ-Board.ino

@@ -103,7 +103,7 @@ void setup() {
   // Explanation: 
    // In this routine the sensor will measure the resistance of the sensor supposedly before being pre-heated
   // and on clean air (Calibration conditions), setting up R0 value.
-  // We recomend executing this routine only on setup in laboratory conditions.
+  // We recommend executing this routine only on setup in laboratory conditions.
   // This routine does not need to be executed on each restart, you can load your R0 value from eeprom.
   // Acknowledgements: https://jayconsystems.com/blog/understanding-a-gas-sensor
   Serial.print("Calibrating please wait.");
@@ -158,8 +158,8 @@ void setup() {
   Serial.print(MQ8calcR0/10); Serial.print(" | ");
   Serial.print(MQ9calcR0/10); Serial.println(" |");
 
-  if(isinf(MQ2calcR0) || isinf(MQ3calcR0) || isinf(MQ4calcR0) || isinf(MQ5calcR0)  || isinf(MQ6calcR0) || isinf(MQ7calcR0) || isinf(MQ8calcR0) || isinf(MQ9calcR0)) {Serial.println("Warning: Conection issue founded, R0 is infite (Open circuit detected) please check your wiring and supply"); while(1);}
+  if(isinf(MQ2calcR0) || isinf(MQ3calcR0) || isinf(MQ4calcR0) || isinf(MQ5calcR0)  || isinf(MQ6calcR0) || isinf(MQ7calcR0) || isinf(MQ8calcR0) || isinf(MQ9calcR0)) {Serial.println("Warning: Connection issue found, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
-  if(MQ2calcR0 == 0 || MQ3calcR0 == 0 || MQ4calcR0 == 0 || MQ5calcR0 == 0 || MQ6calcR0 == 0 || MQ7calcR0 == 0 || MQ8calcR0 == 0 || MQ9calcR0 == 0){Serial.println("Warning: Conection issue founded, R0 is zero (Analog pin with short circuit to ground) please check your wiring and supply"); while(1);}
+  if(MQ2calcR0 == 0 || MQ3calcR0 == 0 || MQ4calcR0 == 0 || MQ5calcR0 == 0 || MQ6calcR0 == 0 || MQ7calcR0 == 0 || MQ8calcR0 == 0 || MQ9calcR0 == 0){Serial.println("Warning: Connection issue found, R0 is zero (Analog pin with short circuit to ground) please check your wiring and supply"); while(1);}
   /*****************************  MQ CAlibration ********************************************/ 
  
   //Print in serial monitor
@@ -201,15 +201,16 @@ void readAllSensors()
   MQ7.update();
   MQ8.update();
   MQ9.update();
+  float correctionFactor = 0; // Optional environmental correction
   //Read the sensor and print in serial port
-  float MQ2Lecture =  MQ2.readSensor();
+  float MQ2Lecture =  MQ2.readSensor(false, correctionFactor);
-  float MQ3Lecture =  MQ3.readSensor();
+  float MQ3Lecture =  MQ3.readSensor(false, correctionFactor);
-  float MQ4Lecture =  MQ4.readSensor();
+  float MQ4Lecture =  MQ4.readSensor(false, correctionFactor);
-  float MQ5Lecture =  MQ5.readSensor();
+  float MQ5Lecture =  MQ5.readSensor(false, correctionFactor);
-  float MQ6Lecture =  MQ6.readSensor();
+  float MQ6Lecture =  MQ6.readSensor(false, correctionFactor);
-  float MQ7Lecture =  MQ7.readSensor();
+  float MQ7Lecture =  MQ7.readSensor(false, correctionFactor);
-  float MQ8Lecture =  MQ8.readSensor();
+  float MQ8Lecture =  MQ8.readSensor(false, correctionFactor);
-  float MQ9Lecture =  MQ9.readSensor();
+  float MQ9Lecture =  MQ9.readSensor(false, correctionFactor);
 
   Serial.print("| "); Serial.print(MQ2Lecture);
   Serial.print("   |   "); Serial.print(MQ3Lecture);

examples/MQ135-ADS1115/MQ135-ADS1115.ino

@@ -62,8 +62,8 @@ void setup(void)
   MQ135.setR0(calcR0/10);
   Serial.println("  done!.");
 
-  if(isinf(calcR0)) {Serial.println("Warning: Conection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
+  if(isinf(calcR0)) {Serial.println("Warning: Connection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
-  if(calcR0 == 0){Serial.println("Warning: Conection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
+  if(calcR0 == 0){Serial.println("Warning: Connection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
   /*****************************  MQ CAlibration ********************************************/ 
   Serial.println("** Values from MQ-135 ****");
   Serial.println("|    CO   |  Alcohol |   CO2  |  Toluen  |  NH4  |  Aceton  |");  
@@ -74,24 +74,25 @@ void loop() {
   short adc0 = ads.readADC_SingleEnded(0);
   float voltios = (adc0 * factorEscala)/1000.0;
   MQ135.externalADCUpdate(voltios); // Update data, the arduino will read the voltage from the analog pin
+  float correctionFactor = 0; // Optional environmental correction
 
   MQ135.setA(605.18); MQ135.setB(-3.937); // Configure the equation to calculate CO concentration value
-  float CO = MQ135.readSensor(); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
+  float CO = MQ135.readSensor(false, correctionFactor); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
 
   MQ135.setA(77.255); MQ135.setB(-3.18); //Configure the equation to calculate Alcohol concentration value
-  float Alcohol = MQ135.readSensor(); // SSensor will read PPM concentration using the model, a and b values set previously or from the setup
+  float Alcohol = MQ135.readSensor(false, correctionFactor); // SSensor will read PPM concentration using the model, a and b values set previously or from the setup
 
   MQ135.setA(110.47); MQ135.setB(-2.862); // Configure the equation to calculate CO2 concentration value
-  float CO2 = MQ135.readSensor(); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
+  float CO2 = MQ135.readSensor(false, correctionFactor); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
 
   MQ135.setA(44.947); MQ135.setB(-3.445); // Configure the equation to calculate Toluen concentration value
-  float Toluen = MQ135.readSensor(); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
+  float Toluen = MQ135.readSensor(false, correctionFactor); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
 
   MQ135.setA(102.2 ); MQ135.setB(-2.473); // Configure the equation to calculate NH4 concentration value
-  float NH4 = MQ135.readSensor(); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
+  float NH4 = MQ135.readSensor(false, correctionFactor); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
 
   MQ135.setA(34.668); MQ135.setB(-3.369); // Configure the equation to calculate Aceton concentration value
-  float Aceton = MQ135.readSensor(); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
+  float Aceton = MQ135.readSensor(false, correctionFactor); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
   Serial.print("|   "); Serial.print(CO); 
   Serial.print("   |   "); Serial.print(Alcohol);
   // Note: 200 Offset for CO2 source: https://github.com/miguel5612/MQSensorsLib/issues/29

examples/UnitTesting/UnitTesting.ino

@@ -27,11 +27,11 @@
 #define         Pin7                     (A7)  //Analog input 7 of your arduino
 #define         Pin8                     (A8)  //Analog input 8 of your arduino
 #define         Pin9                     (A9)  //Analog input 9 of your arduino
-#define         Pin10                    (A10) //Analog input 9 of your arduino
+#define         Pin10                    (A10) //Analog input 10 of your arduino
-#define         Pin11                    (A11) //Analog input 9 of your arduino
+#define         Pin11                    (A11) //Analog input 11 of your arduino
-#define         Pin12                    (A12) //Analog input 9 of your arduino
+#define         Pin12                    (A12) //Analog input 12 of your arduino
-#define         Pin13                    (A13) //Analog input 9 of your arduino
+#define         Pin13                    (A13) //Analog input 13 of your arduino
-#define         Pin14                    (A14) //Analog input 9 of your arduino
+#define         Pin14                    (A14) //Analog input 14 of your arduino
 #define         PWMPin                   (5)   // Pin connected to mosfet
 /***********************Software Related Macros************************************/
 #define         RatioMQ2CleanAir          (9.83) //RS / R0 = 9.83 ppm 
@@ -237,15 +237,25 @@ test(MQ303A_Ethanol)
 {
   MQ303A.setRegressionMethod(1); //_PPM =  a*ratio^b
   MQ303A.setA(3.4916); MQ303A.setB(-2.432); // Configure the equation to to calculate Ethanol concentration
-  MQ303A.init(); 
+  MQ303A.init();
   MQ303A.setR0(10);
-  
+
   int ppmExp=944;
   int PPM = MQ303A.setRsR0RatioGetPPM(0.1); // Send and Rs/R0 and return PPM (Using datasheet)
-  
+
   assertEqual(PPM,ppmExp);
 }
 
+test(MQ303A_VoltResolution)
+{
+  float vRes = 4.7;
+  MQ303A.setVoltResolution(vRes);
+  MQ303A.setADC(100);            // provide dummy ADC value
+  float correctionFactor = 0; // Optional environmental correction
+  MQ303A.readSensor(true, correctionFactor);       // dummy read for MQ303A
+  assertEqualFloat(MQ303A.getVoltResolution(), vRes);
+}
+
 test(MQ309A_CO)
 {
   MQ309A.setRegressionMethod(1); //_PPM =  a*ratio^b

examples/external_A2D/external_A2D.ino

@@ -37,7 +37,7 @@
 //Definitions
 #define placa "Arduino UNO"
 #define Voltage_Resolution 5
-#define pin A0 //Analog input 0 -> This value can have any number, we recomend use A0
+#define pin A0 //Analog input 0 -> This value can have any number, we recommend use A0
 #define type "MQ-3 With A2D External connected" //MQ3
 #define ADC_Bit_Resolution 10 // Resolution of your external A2D
 #define RatioMQ3CleanAir 60   //RS / R0 = 60 ppm 
@@ -74,7 +74,7 @@ void setup() {
   // Explanation: 
    // In this routine the sensor will measure the resistance of the sensor supposedly before being pre-heated
   // and on clean air (Calibration conditions), setting up R0 value.
-  // We recomend executing this routine only on setup in laboratory conditions.
+  // We recommend executing this routine only on setup in laboratory conditions.
   // This routine does not need to be executed on each restart, you can load your R0 value from eeprom.
   // Acknowledgements: https://jayconsystems.com/blog/understanding-a-gas-sensor
   Serial.print("Calibrating please wait.");
@@ -89,8 +89,8 @@ void setup() {
   MQ3.setR0(calcR0/10);
   Serial.println("  done!.");
   
-  if(isinf(calcR0)) {Serial.println("Warning: Conection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
+  if(isinf(calcR0)) {Serial.println("Warning: Connection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
-  if(calcR0 == 0){Serial.println("Warning: Conection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
+  if(calcR0 == 0){Serial.println("Warning: Connection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
   /*****************************  MQ CAlibration ********************************************/ 
 
   MQ3.serialDebug(true);
@@ -99,7 +99,8 @@ void setup() {
 void loop() {
   int yourA2DValue = random(0, 1024); // 10-bit emulation
   MQ3.setADC(yourA2DValue); // Update data, the arduino will read the voltage from the analog pin
-  MQ3.readSensor(); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
+  float correctionFactor = 0; // Optional environmental correction
+  MQ3.readSensor(false, correctionFactor); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
   MQ3.serialDebug(); // Will print the table on the serial port
   delay(500); //Sampling frequency
 }

examples/smokeDetector/smokeDetector.ino

@@ -59,7 +59,7 @@ void setup() {
   // Explanation: 
    // In this routine the sensor will measure the resistance of the sensor supposedly before being pre-heated
   // and on clean air (Calibration conditions), setting up R0 value.
-  // We recomend executing this routine only on setup in laboratory conditions.
+  // We recommend executing this routine only on setup in laboratory conditions.
   // This routine does not need to be executed on each restart, you can load your R0 value from eeprom.
   // Acknowledgements: https://jayconsystems.com/blog/understanding-a-gas-sensor
   Serial.print("Calibrating please wait.");
@@ -73,8 +73,8 @@ void setup() {
   MQ4.setR0(calcR0/10);
   Serial.println("  done!.");
   
-  if(isinf(calcR0)) {Serial.println("Warning: Conection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
+  if(isinf(calcR0)) {Serial.println("Warning: Connection issue, R0 is infinite (Open circuit detected) please check your wiring and supply"); while(1);}
-  if(calcR0 == 0){Serial.println("Warning: Conection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
+  if(calcR0 == 0){Serial.println("Warning: Connection issue found, R0 is zero (Analog pin shorts to ground) please check your wiring and supply"); while(1);}
   /*****************************  MQ CAlibration ********************************************/ 
   MQ4.serialDebug(true);
 }
@@ -88,7 +88,8 @@ void setup() {
   //Read the sensor and print in serial port
   //Lecture will be saved in lecture variable
   MQ4.update();
-  float smokePPM = MQ4.readSensor(); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
+  float correctionFactor = 0; // Optional environmental correction
+  float smokePPM = MQ4.readSensor(false, correctionFactor); // Sensor will read PPM concentration using the model, a and b values set previously or from the setup
   if(smokePPM > 1000) {Serial.println("Warning: High concentrations of smoke detected");}
   MQ4.serialDebug(); // Will print the table on the serial port
   delay(400);  

keywords.txt

@@ -0,0 +1,29 @@
+MQUnifiedsensor KEYWORD1
+init KEYWORD2
+update KEYWORD2
+externalADCUpdate KEYWORD2
+setR0 KEYWORD2
+setRL KEYWORD2
+setA KEYWORD2
+setB KEYWORD2
+setRegressionMethod KEYWORD2
+setVoltResolution KEYWORD2
+setVCC KEYWORD2
+setPin KEYWORD2
+setADC KEYWORD2
+serialDebug KEYWORD2
+calibrate KEYWORD2
+readSensor KEYWORD2
+readSensorR0Rs KEYWORD2
+validateEcuation KEYWORD2
+getVoltage KEYWORD2
+setRsR0RatioGetPPM KEYWORD2
+getRS KEYWORD2
+stringTofloat KEYWORD2
+getA KEYWORD2
+getB KEYWORD2
+getR0 KEYWORD2
+getRL KEYWORD2
+getVoltResolution KEYWORD2
+getVCC KEYWORD2
+getRegressionMethod KEYWORD2

library.properties

@@ -1,5 +1,5 @@
 name=MQUnifiedsensor
-version=3.0.0
+version=3.0.5
 author= Miguel Califa <miguelangel5612@gmail.com>, Yersson Carrillo<miguelangel5612@gmail.com>, Ghiordy Contreras<miguelangel5612@gmail.com>
 maintainer= Miguel Califa <miguelangel5612@gmail.com>
 sentence= This library allows you to read the MQ sensors very easily.

src/MQUnifiedsensor.cpp

@@ -1,27 +1,61 @@
 #include "MQUnifiedsensor.h"
+#include <float.h>
+#include <math.h>
+
+#define retries 2
+#define retry_interval 20
 
 MQUnifiedsensor::MQUnifiedsensor(String Placa, float Voltage_Resolution, int ADC_Bit_Resolution, int pin, String type) {
   this->_pin = pin;
   Placa.toCharArray(this->_placa, 20);
-  type.toCharArray(this->_type, 6);
+  type.toCharArray(this->_type, 7);
   //this->_type = type; //MQ-2, MQ-3 ... MQ-309A
   //this->_placa = Placa;
   this-> _VOLT_RESOLUTION = Voltage_Resolution;
+  this-> _VCC = Voltage_Resolution;
   this-> _ADC_Bit_Resolution = ADC_Bit_Resolution;
 }
 MQUnifiedsensor::MQUnifiedsensor(String Placa, String type) {
   Placa.toCharArray(this->_placa, 20);
-  type.toCharArray(this->_type, 6);
+  type.toCharArray(this->_type, 7);
 }
 void MQUnifiedsensor::init()
 {
   pinMode(_pin, INPUT);
 }
+static inline double safePow(double base, double exp){
+  if(exp == 0.0) return 1.0;
+  if(exp == 1.0) return base;
+  if(exp == 2.0) return base * base;
+  return pow(base, exp);
+}
+static inline bool willOverflow(double log_ppm){
+  static const double maxLog = log10((double)FLT_MAX);
+  static const double minLog = log10((double)FLT_MIN);
+  return (log_ppm > maxLog || log_ppm < minLog);
+}
+
 void MQUnifiedsensor::setA(float a) {
-  this->_a = a;
+  if(isinf(a) || isnan(a)) {
+    this->_a = 0;
+  } else if(a > MQ_MAX_A) {
+    this->_a = MQ_MAX_A;
+  } else if(a < -MQ_MAX_A) {
+    this->_a = -MQ_MAX_A;
+  } else {
+    this->_a = a;
+  }
 }
 void MQUnifiedsensor::setB(float b) {
-  this->_b = b;
+  if(isinf(b) || isnan(b)) {
+    this->_b = 0;
+  } else if(b > MQ_MAX_B) {
+    this->_b = MQ_MAX_B;
+  } else if(b < -MQ_MAX_B) {
+    this->_b = -MQ_MAX_B;
+  } else {
+    this->_b = b;
+  }
 }
 void MQUnifiedsensor::setR0(float R0) {
   this->_R0 = R0;
@@ -38,6 +72,13 @@ void MQUnifiedsensor::setVoltResolution(float voltage_resolution)
 {
   _VOLT_RESOLUTION = voltage_resolution;
 }
+void MQUnifiedsensor::setVCC(float vcc)
+{
+  _VCC = vcc;
+}
+void MQUnifiedsensor::setPin(int pin) {
+  this->_pin = pin;
+}
 void MQUnifiedsensor::setRegressionMethod(int regressionMethod)
 {
   //this->_regressionMethod = regressionMethod;
@@ -53,6 +94,10 @@ float MQUnifiedsensor::getVoltResolution()
 {
   return _VOLT_RESOLUTION;
 }
+float MQUnifiedsensor::getVCC()
+{
+  return _VCC;
+}
 String MQUnifiedsensor::getRegressionMethod()
 {
   if(_regressionMethod == 1) return "Exponential";
@@ -79,7 +124,8 @@ void MQUnifiedsensor::serialDebug(bool onSetup)
     Serial.println("Contributors: Andres A. Martinez - Juan A. Rodríguez - Mario A. Rodríguez O ");
 
     Serial.print("Sensor: "); Serial.println(_type);
-    Serial.print("Supply voltage: "); Serial.print(_VOLT_RESOLUTION); Serial.println(" VDC");
+    Serial.print("ADC voltage: "); Serial.print(_VOLT_RESOLUTION); Serial.println(" VDC");
+    Serial.print("Sensor supply (VCC): "); Serial.print(_VCC); Serial.println(" VDC");
     Serial.print("ADC Resolution: "); Serial.print(_ADC_Bit_Resolution); Serial.println(" Bits");
     Serial.print("R0: "); Serial.print(_R0); Serial.println(" KΩ");
     Serial.print("RL: "); Serial.print(_RL); Serial.println(" KΩ");
@@ -100,7 +146,7 @@ void MQUnifiedsensor::serialDebug(bool onSetup)
     else
     {
       Serial.print("|"); Serial.print(_adc);  Serial.print("| v = ADC*"); Serial.print(_VOLT_RESOLUTION); Serial.print("/"); Serial.print((pow(2, _ADC_Bit_Resolution)) - 1); Serial.print("  |    "); Serial.print(_sensor_volt);
-      Serial.print("     | RS = ((" ); Serial.print(_VOLT_RESOLUTION ); Serial.print("*RL)/Voltage) - RL|      "); Serial.print(_RS_Calc); Serial.print("     | Ratio = RS/R0|    ");
+      Serial.print("     | RS = ((" ); Serial.print(_VCC ); Serial.print("*RL)/Voltage) - RL|      "); Serial.print(_RS_Calc); Serial.print("     | Ratio = RS/R0|    ");
       Serial.print(_ratio);  Serial.print( "       |   ");
       if(_regressionMethod == 1) Serial.print("ratio*a + b");
       else Serial.print("pow(10, (log10(ratio)-b)/a)");
@@ -118,62 +164,86 @@ void MQUnifiedsensor::externalADCUpdate(float volt)
 }
 float MQUnifiedsensor::validateEcuation(float ratioInput)
 {
-  //Serial.print("Ratio input: "); Serial.println(ratioInput);
+  double ppm;
-  //Serial.print("a: "); Serial.println(_a);
+  if(_regressionMethod == 1){
-  //Serial.print("b: "); Serial.println(_b);
+      if(ratioInput <= 0 || _a == 0) return 0;
-  //Usage of this function: Unit test on ALgorithmTester example;
+      double logppm = log10((double)_a) + (double)_b * log10((double)ratioInput);
-  if(_regressionMethod == 1) _PPM= _a*pow(ratioInput, _b);
+      if(willOverflow(logppm)) ppm = (logppm > 0) ? FLT_MAX : 0.0;
-  else 
+      else ppm = safePow(10.0, logppm);
-  {
-      // https://jayconsystems.com/blog/understanding-a-gas-sensor
-      double ppm_log = (log10(ratioInput)-_b)/_a; //Get ppm value in linear scale according to the the ratio value  
-      _PPM = pow(10, ppm_log); //Convert ppm value to log scale  
   }
-  //Serial.println("Regression Method: "); Serial.println(_regressionMethod);
+  else
-  //Serial.println("Result: "); Serial.println(_PPM);
+  {
-  return _PPM;  
+      if(ratioInput <= 0 || _a == 0) return 0;
+      double logppm = (log10((double)ratioInput)-(double)_b)/(double)_a;
+      if(willOverflow(logppm)) ppm = (logppm > 0) ? FLT_MAX : 0.0;
+      else ppm = safePow(10.0, logppm);
+  }
+  if(isinf(ppm) || isnan(ppm)) ppm = FLT_MAX;
+  _PPM = (float)ppm;
+  return _PPM;
 }
 float MQUnifiedsensor::readSensor(bool isMQ303A, float correctionFactor, bool injected)
 {
   //More explained in: https://jayconsystems.com/blog/understanding-a-gas-sensor
+
+  float voltRes = _VOLT_RESOLUTION; // preserve global resolution
   if(isMQ303A) {
-    _VOLT_RESOLUTION = _VOLT_RESOLUTION - 0.45; //Calculations for RS using mq303a sensor look wrong #42
+    voltRes = voltRes - 0.45; //Calculations for RS using mq303a sensor look wrong #42
   }
-  _RS_Calc = ((_VOLT_RESOLUTION*_RL)/_sensor_volt)-_RL; //Get value of RS in a gas
+  _RS_Calc = ((_VCC*_RL)/_sensor_volt)-_RL; //Get value of RS in a gas
   if(_RS_Calc < 0)  _RS_Calc = 0; //No negative values accepted.
   if(!injected) _ratio = _RS_Calc / this->_R0;   // Get ratio RS_gas/RS_air
   _ratio += correctionFactor;
-  if(_ratio <= 0)  _ratio = 0; //No negative values accepted or upper datasheet recomendation.
+  if(_ratio <= 0)  _ratio = 0; //No negative values accepted or upper datasheet recommendation.
-  if(_regressionMethod == 1) _PPM= _a*pow(_ratio, _b); // <- Source excel analisis https://github.com/miguel5612/MQSensorsLib_Docs/tree/master/Internal_design_documents
+  double ppm;
-  else 
+  if(_regressionMethod == 1){
-  {
+    if(_ratio <= 0 || _a == 0) return 0;
-    // https://jayconsystems.com/blog/understanding-a-gas-sensor <- Source of linear ecuation
+    double logppm = log10((double)_a) + (double)_b * log10((double)_ratio);
-    double ppm_log = (log10(_ratio)-_b)/_a; //Get ppm value in linear scale according to the the ratio value  
+    if(willOverflow(logppm)) ppm = (logppm > 0) ? FLT_MAX : 0.0;
-    _PPM = pow(10, ppm_log); //Convert ppm value to log scale  
+    else ppm = safePow(10.0, logppm);
   }
-  if(_PPM < 0)  _PPM = 0; //No negative values accepted or upper datasheet recomendation.
+  else
-  //if(_PPM > 10000) _PPM = 99999999; //No negative values accepted or upper datasheet recomendation.
+  {
+    if(_ratio <= 0 || _a == 0) return 0;
+    double logppm = (log10((double)_ratio)-(double)_b)/(double)_a;
+    if(willOverflow(logppm)) ppm = (logppm > 0) ? FLT_MAX : 0.0;
+    else ppm = safePow(10.0, logppm);
+  }
+  if(ppm < 0)  ppm = 0; //No negative values accepted or upper datasheet recommendation.
+  if(isinf(ppm) || isnan(ppm)) ppm = FLT_MAX;
+  _PPM = (float)ppm;
+  //if(_PPM > 10000) _PPM = 99999999; //No negative values accepted or upper datasheet recommendation.
   return _PPM;
 }
-float MQUnifiedsensor::readSensorR0Rs()
+float MQUnifiedsensor::readSensorR0Rs(float correctionFactor)
 {
   //More explained in: https://jayconsystems.com/blog/understanding-a-gas-sensor
-  _RS_Calc = ((_VOLT_RESOLUTION*_RL)/_sensor_volt)-_RL; //Get value of RS in a gas
+  _RS_Calc = ((_VCC*_RL)/_sensor_volt)-_RL; //Get value of RS in a gas
   if(_RS_Calc < 0)  _RS_Calc = 0; //No negative values accepted.
   _ratio = this->_R0/_RS_Calc;   // Get ratio RS_air/RS_gas <- INVERTED for MQ-131 issue 28 https://github.com/miguel5612/MQSensorsLib/issues/28
-  if(_ratio <= 0)  _ratio = 0; //No negative values accepted or upper datasheet recomendation.
+  _ratio += correctionFactor;
-  if(_regressionMethod == 1) _PPM= _a*pow(_ratio, _b); // <- Source excel analisis https://github.com/miguel5612/MQSensorsLib_Docs/tree/master/Internal_design_documents
+  if(_ratio <= 0)  _ratio = 0; //No negative values accepted or upper datasheet recommendation.
-  else 
+  double ppm;
-  {
+  if(_regressionMethod == 1){
-    // https://jayconsystems.com/blog/understanding-a-gas-sensor <- Source of linear ecuation
+    if(_ratio <= 0 || _a == 0) return 0;
-    double ppm_log = (log10(_ratio)-_b)/_a; //Get ppm value in linear scale according to the the ratio value  
+    double logppm = log10((double)_a) + (double)_b * log10((double)_ratio);
-    _PPM = pow(10, ppm_log); //Convert ppm value to log scale  
+    if(willOverflow(logppm)) ppm = (logppm > 0) ? FLT_MAX : 0.0;
+    else ppm = safePow(10.0, logppm);
   }
-  if(_PPM < 0)  _PPM = 0; //No negative values accepted or upper datasheet recomendation.
+  else
-  //if(_PPM > 10000) _PPM = 99999999; //No negative values accepted or upper datasheet recomendation.
+  {
+    if(_ratio <= 0 || _a == 0) return 0;
+    double logppm = (log10((double)_ratio)-(double)_b)/(double)_a;
+    if(willOverflow(logppm)) ppm = (logppm > 0) ? FLT_MAX : 0.0;
+    else ppm = safePow(10.0, logppm);
+  }
+  if(ppm < 0)  ppm = 0; //No negative values accepted or upper datasheet recommendation.
+  if(isinf(ppm) || isnan(ppm)) ppm = FLT_MAX;
+  _PPM = (float)ppm;
+  //if(_PPM > 10000) _PPM = 99999999; //No negative values accepted or upper datasheet recommendation.
   return _PPM;
 }
-float MQUnifiedsensor::calibrate(float ratioInCleanAir) {
+float MQUnifiedsensor::calibrate(float ratioInCleanAir, float correctionFactor) {
   //More explained in: https://jayconsystems.com/blog/understanding-a-gas-sensor
   /*
   V = I x R 
@@ -188,9 +258,10 @@ float MQUnifiedsensor::calibrate(float ratioInCleanAir) {
   */
   float RS_air; //Define variable for sensor resistance
   float R0; //Define variable for R0
-  RS_air = ((_VOLT_RESOLUTION*_RL)/_sensor_volt)-_RL; //Calculate RS in fresh air
+  RS_air = ((_VCC*_RL)/_sensor_volt)-_RL; //Calculate RS in fresh air
   if(RS_air < 0)  RS_air = 0; //No negative values accepted.
-  R0 = RS_air/ratioInCleanAir; //Calculate R0 
+  R0 = RS_air/ratioInCleanAir; //Calculate R0
+  R0 += correctionFactor;
   if(R0 < 0)  R0 = 0; //No negative values accepted.
   return R0;
 }
@@ -225,7 +296,7 @@ float MQUnifiedsensor:: setRsR0RatioGetPPM(float value)
 float MQUnifiedsensor::getRS()
 {
   //More explained in: https://jayconsystems.com/blog/understanding-a-gas-sensor
-  _RS_Calc = ((_VOLT_RESOLUTION*_RL)/_sensor_volt)-_RL; //Get value of RS in a gas
+  _RS_Calc = ((_VCC*_RL)/_sensor_volt)-_RL; //Get value of RS in a gas
   if(_RS_Calc < 0)  _RS_Calc = 0; //No negative values accepted.
   return _RS_Calc;
 }
@@ -233,4 +304,4 @@ float MQUnifiedsensor::getRS()
 float MQUnifiedsensor::stringTofloat(String & str)
 {
   return atof( str.c_str() );
-}
+}

src/MQUnifiedsensor.h

@@ -3,13 +3,15 @@
 
 #include <Arduino.h>
 #include <stdint.h>
+#include <float.h>
+#include <math.h>
+
+// Maximum coefficients allowed for the regression model
+#define MQ_MAX_A 1e30
+#define MQ_MAX_B 100.0
 
 /***********************Software Related Macros************************************/
 
-#define ADC_RESOLUTION 10 // for 10bit analog to digital converter.
-#define retries 2
-#define retry_interval 20
-
 class MQUnifiedsensor
 {
   public:
@@ -26,13 +28,15 @@ class MQUnifiedsensor
     void setB(float b);
     void setRegressionMethod(int regressionMethod);
     void setVoltResolution(float voltage_resolution =  5);
+    void setVCC(float vcc = 5);
+    void setPin(int pin = 1);
     void serialDebug(bool onSetup = false); //Show on serial port information about sensor
     void setADC(int value); //For external ADC Usage
     
     //user functions
-    float calibrate(float ratioInCleanAir);
+    float calibrate(float ratioInCleanAir, float correctionFactor = 0.0);
     float readSensor(bool isMQ303A = false, float correctionFactor = 0.0, bool injected=false);
-    float readSensorR0Rs();
+    float readSensorR0Rs(float correctionFactor = 0.0);
     float validateEcuation(float ratioInput = 0);
     
     //get function for info
@@ -41,6 +45,7 @@ class MQUnifiedsensor
     float getR0();
     float getRL();
     float getVoltResolution();
+    float getVCC();
     String getRegressionMethod();
     float getVoltage(bool read = true, bool injected = false, int value = 0);
     float stringTofloat(String & str);
@@ -51,9 +56,10 @@ class MQUnifiedsensor
 
   private:
     /************************Private vars************************************/
-    byte _pin;
+    byte _pin = 1;
     byte _firstFlag = false;
     float _VOLT_RESOLUTION  = 5.0; // if 3.3v use 3.3
+    float _VCC = 5.0; // Sensor supply voltage
     float _RL = 10; //Value in KiloOhms
     byte _ADC_Bit_Resolution = 10;
     byte _regressionMethod = 1; // 1 -> Exponential || 2 -> Linear
@@ -61,7 +67,7 @@ class MQUnifiedsensor
     float _adc, _a, _b, _sensor_volt;
     float  _R0, RS_air, _ratio, _PPM, _RS_Calc;  
     
-    char _type[6];
+    char _type[7];
     char _placa[20]; 
 };