void setup() {
    Serial.begin(9600);
}

void loop() {
    float sensor_volt;
    float sensorValue;

    sensorValue = analogRead(A0);
    sensor_volt = sensorValue/1024*5.0;

    Serial.print("sensor_volt = ");
    Serial.print(sensor_volt);
    Serial.println("V");
    delay(1000);
}

void setup() {
    Serial.begin(9600);
}

void loop() {
    float sensor_volt;
    float sensorValue;

    sensorValue = analogRead(A0);
    sensor_volt = sensorValue/1024*5.0;

    Serial.print("sensor_volt = ");
    Serial.print(sensor_volt);
    Serial.println("V");
    delay(1000);
}

#include "SCD30.h"

#if defined(ARDUINO_ARCH_AVR)
 #pragma message("Defined architecture for ARDUINO_ARCH_AVR.")
 #define SERIAL Serial
#elif defined(ARDUINO_ARCH_SAM)
 #pragma message("Defined architecture for ARDUINO_ARCH_SAM.")
 #define SERIAL SerialUSB
#elif defined(ARDUINO_ARCH_SAMD)
 #pragma message("Defined architecture for ARDUINO_ARCH_SAMD.") 
 #define SERIAL SerialUSB
#elif defined(ARDUINO_ARCH_STM32F4)
 #pragma message("Defined architecture for ARDUINO_ARCH_STM32F4.")
 #define SERIAL SerialUSB
#else
 #pragma message("Not found any architecture.")
 #define SERIAL Serial
#endif



void setup()
{
    Wire.begin();
    SERIAL.begin(115200);
    SERIAL.println("SCD30 Raw Data");
    scd30.initialize();
}

void loop()
{
    float result[3] = {0};
    
    if(scd30.isAvailable())
    {
        scd30.getCarbonDioxideConcentration(result);
        SERIAL.print("Carbon Dioxide Concentration is: ");
        SERIAL.print(result[0]);
        SERIAL.println(" ppm");
        SERIAL.println(" ");
        SERIAL.print("Temperature = ");
        SERIAL.print(result[1]);
        SERIAL.println(" ℃");
        SERIAL.println(" ");
        SERIAL.print("Humidity = ");
        SERIAL.print(result[2]);
        SERIAL.println(" %");
        SERIAL.println(" ");
        SERIAL.println(" ");
        SERIAL.println(" ");
    }
    
    delay(2000);
}

/*
  This test code is write for Arduino AVR Series(UNO, Leonardo, Mega)
  If you want to use with LinkIt ONE, please connect the module to D0/1 and modify:

  // #include <SoftwareSerial.h>
  // SoftwareSerial s_serial(2, 3);      // TX, RX

  #define sensor Serial1
*/


#include <SoftwareSerial.h>
SoftwareSerial s_serial(2, 3);      // TX, RX

#define sensor s_serial

const unsigned char cmd_get_sensor[] =
{
    0xff, 0x01, 0x86, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x79
};

unsigned char dataRevice[9];
int CO2PPM;

void setup()
{
    sensor.begin(9600);
    Serial.begin(9600);
    Serial.println("get a 'g', begin to read from sensor!");
    Serial.println("********************************************************");
    Serial.println();
}

void loop()
{
    if(dataRecieve())
    {
        Serial.print("  CO2: ");
        Serial.print(CO2PPM);
        Serial.println("");
    }
    delay(10000);
}

bool dataRecieve(void)
{
    byte data[9];
    int i = 0;

    //transmit command data
    for(i=0; i<sizeof(cmd_get_sensor); i++)
    {
        sensor.write(cmd_get_sensor[i]);
    }
    Serial.flush();
    
    //begin reveiceing data
    if(sensor.available())
    {
        while(sensor.available())
        {
            for(int i=0;i<9; i++)
            {
                data[i] = sensor.read();
            }
        }
    }

    for(int j=0; j<9; j++)
    {
        Serial.print(data[j],HEX);
        Serial.print(" ");
    }
    Serial.println("");

    // First calculate then validate the check sum as there is no point in proceeding if the packet is corrupted. (code inspired by datasheet algorithm)
    byte checksum = 0 ;
    for(int j=1; j<8; j++)
    {
      checksum += data[j];
    }
    checksum=0xff-checksum; 
    checksum+=1;
       
    if  (checksum != data[8])
    {
      Serial.println("Error checksum");
      return false;
    }

    // Then check the start byte to make sure response is what we were expecting
    if ( data[0] != 0xFF )
    {
        Serial.println("Error start byte");
        return false;
    }

    // Then check the command byte to make sure response is what we were expecting
    if ( data[1] != 0x86 )
    {
        Serial.println("Error command");
        return false;
    }


    CO2PPM = (int)data[2] * 256 + (int)data[3];

    return true;
}

/*!
 *  @file DHT.h
 *
 *  This is a library for DHT series of low cost temperature/humidity sensors.
 *
 *  You must have Adafruit Unified Sensor Library library installed to use this
 * class.
 *
 *  Adafruit invests time and resources providing this open source code,
 *  please support Adafruit andopen-source hardware by purchasing products
 *  from Adafruit!
 *
 *  Written by Adafruit Industries.
 *
 *  MIT license, all text above must be included in any redistribution
 */

#ifndef DHT_H
#define DHT_H

#include "Arduino.h"

/* Uncomment to enable printing out nice debug messages. */
//#define DHT_DEBUG

#define DEBUG_PRINTER                                                          \
  Serial /**< Define where debug output will be printed.                       \
          */

/* Setup debug printing macros. */
#ifdef DHT_DEBUG
#define DEBUG_PRINT(...)                                                       \
  { DEBUG_PRINTER.print(__VA_ARGS__); }
#define DEBUG_PRINTLN(...)                                                     \
  { DEBUG_PRINTER.println(__VA_ARGS__); }
#else
#define DEBUG_PRINT(...)                                                       \
  {} /**< Debug Print Placeholder if Debug is disabled */
#define DEBUG_PRINTLN(...)                                                     \
  {} /**< Debug Print Line Placeholder if Debug is disabled */
#endif

/* Define types of sensors. */
static const uint8_t DHT11{11};  /**< DHT TYPE 11 */
static const uint8_t DHT12{12};  /**< DHY TYPE 12 */
static const uint8_t DHT21{21};  /**< DHT TYPE 21 */
static const uint8_t DHT22{22};  /**< DHT TYPE 22 */
static const uint8_t AM2301{21}; /**< AM2301 */

#if defined(TARGET_NAME) && (TARGET_NAME == ARDUINO_NANO33BLE)
#ifndef microsecondsToClockCycles
/*!
 * As of 7 Sep 2020 the Arduino Nano 33 BLE boards do not have
 * microsecondsToClockCycles defined.
 */
#define microsecondsToClockCycles(a) ((a) * (SystemCoreClock / 1000000L))
#endif
#endif

/*!
 *  @brief  Class that stores state and functions for DHT
 */
class DHT {
public:
  DHT(uint8_t pin, uint8_t type, uint8_t count = 6);
  void begin(uint8_t usec = 55);
  float readTemperature(bool S = false, bool force = false);
  float convertCtoF(float);
  float convertFtoC(float);
  float computeHeatIndex(bool isFahrenheit = true);
  float computeHeatIndex(float temperature, float percentHumidity,
                         bool isFahrenheit = true);
  float readHumidity(bool force = false);
  bool read(bool force = false);

private:
  uint8_t data[5];
  uint8_t _pin, _type;
#ifdef __AVR
  // Use direct GPIO access on an 8-bit AVR so keep track of the port and
  // bitmask for the digital pin connected to the DHT.  Other platforms will use
  // digitalRead.
  uint8_t _bit, _port;
#endif
  uint32_t _lastreadtime, _maxcycles;
  bool _lastresult;
  uint8_t pullTime; // Time (in usec) to pull up data line before reading

  uint32_t expectPulse(bool level);
};

/*!
 *  @brief  Class that defines Interrupt Lock Avaiability
 */
class InterruptLock {
public:
  InterruptLock() {
#if !defined(ARDUINO_ARCH_NRF52)
    noInterrupts();
#endif
  }
  ~InterruptLock() {
#if !defined(ARDUINO_ARCH_NRF52)
    interrupts();
#endif
  }
};

#endif

#include <SPI.h>
#include <SD.h>

const int chipSelect = SDCARD_SS_PIN;

void setup() {
  // Open serial communications and wait for port to open:
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }


  Serial.print("Initializing SD card...");

  // see if the card is present and can be initialized:
  if (!SD.begin(chipSelect)) {
    Serial.println("Card failed, or not present");
    // don't do anything more:
    while (1);
  }
  Serial.println("card initialized.");
}

void loop() {
  // make a string for assembling the data to log:
  String dataString = "";

  // read three sensors and append to the string:
  for (int analogPin = 0; analogPin < 3; analogPin++) {
    int sensor = analogRead(analogPin);
    dataString += String(sensor);
    if (analogPin < 2) {
      dataString += ",";
    }
  }

  // open the file. note that only one file can be open at a time,
  // so you have to close this one before opening another.
  File dataFile = SD.open("datalog.txt", FILE_WRITE);

  // if the file is available, write to it:
  if (dataFile) {
    dataFile.println(dataString);
    dataFile.close();
    // print to the serial port too:
    Serial.println(dataString);
  }
  // if the file isn't open, pop up an error:
  else {
    Serial.println("error opening datalog.txt");
  }
  delay(1000);
}

#include<MQ2.h>

#define PIN A0

MQ2 mq2(PIN);

void setup() {
  Serial.begin(9600);
  mq2.begin();

}

void loop() {
  int lpg = mq2.readLPG();
  int co = mq2.readCO();
  int smo = mq2.readSmoke();
  Serial.print("Smoke: ");
  Serial.print(smo);
  Serial.print("  LPG: ");
  Serial.print(lpg);
  Serial.print("  CO2: ");
  Serial.println(co);
  delay(2000);
}

/*
  Scheduled Datalogger

  Demonstrates how to log temperature and humidity sensor
  reading and time using a MKRZero, then you can plot the
  graph of the temperature and humidity in a romm during 
  the whole day!

  This example code is in the public domain

  Parts required:
  1 DHT22 temperature and humidity sensor
  1 MKR protoshield

  created by Arturo Guadalupi <a.guadalupi@arduino.cc>
  3 Nov 2016
*/
#include <SD.h>
#include <RTCZero.h>
#include <DHT.h>

#define DHTPIN 7
#define DHTTYPE DHT22
DHT dht(DHTPIN, DHTTYPE);

const int chipSelect = SS1;
unsigned long previousTime;

int loadDataCheck;  //Checks if data needs to be loaded 

RTCZero rtc;

/* Change these values to set the current initial time */
const byte seconds = 50;
const byte minutes = 44;
const byte hours = 17;

/* Change these values to set the current initial date */
const byte day = 1;
const byte month = 9;
const byte year = 16;

// the setup function runs once when you press reset
// or power the board
void setup() {
  // initialize digital pin LED_BUILTIN as an output.
  pinMode(LED_BUILTIN, OUTPUT);
  Serial.begin(9600);    
  
  Serial.println("DataLogger Example:"); 
  
   // see if the card is present and can be initialized:
  if (!SD.begin(chipSelect)) {
    Serial.println("Card failed, or not present");
    // don't do anything more:
    return;
    
  }  
  Serial.println("card initialized.");

  //When power is supplied to the DHT22 sensor,
  //don't send any instruction to the sensor
  //within one second to pass unstable status
  delay(1000);
  Serial.println("Initializing DHT");
  dht.begin();
  
  Serial.println("Initializing RTC");
  rtc.begin();
  rtc.setTime(hours, minutes, seconds);
  rtc.setDate(day, month, year);

  rtc.setAlarmTime(0, 0, 0);
  rtc.enableAlarm(rtc.MATCH_SS); //alarm attached every minute

  rtc.attachInterrupt(dataCheck);

  loadDataCheck=0;

  previousTime=millis();
  
  Serial.println("System ready...");  
}

// the loop function runs over and over again forever
void loop() {
  unsigned long currentTime=millis();
  if ((currentTime-previousTime)>5000)
  {
    digitalWrite(LED_BUILTIN, HIGH);  // turn the LED on 
    delay(100);                       // wait for a bit
    digitalWrite(LED_BUILTIN, LOW);   // turn the LED off 
    previousTime=millis();
  }                       
  if (loadDataCheck) logData();  
}

void dataCheck(){
  loadDataCheck=1;
}

void logData(void) {     
  float humidity = dht.readHumidity();  
  float temperature = dht.readTemperature();
  
  String dataString = "";
  dataString += "Temperature: " + String(temperature) + " C" + "\t" + "Humidity: " + String(humidity) + "%\t" + "Time: " + getTime();  
  // open the file. note that only one file can be open at a time,
  // so you have to close this one before opening another.
  File dataFile = SD.open("datalog.txt", FILE_WRITE);

  // if the file is available, write to it:
  if (dataFile) {
    dataFile.println(dataString);
    dataFile.close();
    // print to the Serial port too:
    Serial.println(dataString);
  }
  // if the file isn't open, pop up an error:
  else {
    Serial.println("error opening datalog.txt");
  }
  loadDataCheck=0;
}

String getTime(void) {
  String returnString = "";

  if (rtc.getHours() < 10)
    returnString += "0" + String(rtc.getHours());
  else
    returnString += String(rtc.getHours());

  returnString += ":";

  if (rtc.getMinutes() < 10)
    returnString += "0" + String(rtc.getMinutes());
  else
    returnString += String(rtc.getMinutes());

  returnString += ":";

  if (rtc.getSeconds() < 10)
    returnString += "0" + String(rtc.getSeconds());
  else
    returnString += String(rtc.getSeconds());

  return returnString;
}

 #include <SPI.h>
#include <SD.h>
#include <Wire.h>


#include "SCD30.h"
float result[3] = {0}; // sensor readings


const int chipSelect = SDCARD_SS_PIN;

void setup() {
  Wire.begin();
  Serial.println("SCD30 Raw Data");
  scd30.initialize();
  // Open serial communications and wait for port to open:
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }


  Serial.print("Initializing SD card...");

  // see if the card is present and can be initialized:
  if (!SD.begin(chipSelect)) {
    Serial.println("Card failed, or not present");
  // don't do anything more:
   while (1);
  }
  Serial.println("card initialized.");
}

void loop() {
  if (scd30.isAvailable()) {
    scd30.getCarbonDioxideConcentration(result);
    Serial.print("Carbon Dioxide Concentration is: ");
    Serial.print(result[0]);
    Serial.println(" ppm");
  }
  
  // make a string for assembling the data to log:
  String dataString = "";

  // read three sensors and append to the string:
  for (int analogPin = 0; analogPin < 3; analogPin++) {
    float sensor = result[analogPin];
    dataString += String(sensor);
    if (analogPin < 2) {
      dataString += ",";
    }
  }

  // open the file. note that only one file can be open at a time,
  // so you have to close this one before opening another.
  File dataFile = SD.open("datalog.txt", FILE_WRITE);

  // if the file is available, write to it:
  if (dataFile) {
    dataFile.println(dataString);
    dataFile.close();
   // print to the serial port too:
    Serial.println(dataString);
  }
  // if the file isn't open, pop up an error:
  else {
    Serial.println("error opening datalog.txt");
  }
  delay(1000);
}

#include <SPI.h>
#include <SD.h>
#include <Wire.h>
#include "SCD30.h"
#include <RTCZero.h>

float result[3] = {0}; // sensor readings
const int chipSelect = SDCARD_SS_PIN;

/* Create an rtc object */
RTCZero rtc;
const byte seconds = 0;
const byte minutes = 0;
const byte hours = 16;
const byte day = 23;
const byte month = 1;
const byte year = 24;


void setup() {
   Wire.begin();
   scd30.initialize();
  // Open serial communications and wait for port to open:
  Serial.begin(9600);
  while (!Serial)
   {
    ; // wait for serial port to connect. Needed for native USB port only
  }


  Serial.print("Initializing SD card...");

  // see if the card is present and can be initialized:
  if (!SD.begin(chipSelect)) {
    Serial.println("Card failed, or not present");
    // don't do anything more:
    while (1);
  }
  Serial.println("card initialized.");

  rtc.begin(); // initialize RTC

  rtc.setHours(hours);
  rtc.setMinutes(minutes);
  rtc.setSeconds(seconds);
  rtc.setDay(day);
  rtc.setMonth(month);
  rtc.setYear(year);

}

void loop() {
  Serial.print(rtc.getDay());
  Serial.print("/");
  Serial.print(rtc.getMonth());
  Serial.print("/");
  Serial.print(rtc.getYear());
  Serial.print(" ");
  Serial.print(rtc.getHours());
  Serial.print(":");
  Serial.print(rtc.getMinutes());
  Serial.print(":");
  Serial.print(rtc.getSeconds());
  Serial.println();
  // make a string for assembling the data to log:
  String dataString = "";

  //if (scd30.isAvailable()) 
    scd30.getCarbonDioxideConcentration(result);
    Serial.print("Carbon Dioxide Concentration is: ");
    Serial.print(result[0]);
    Serial.println(" ppm");
  

  dataString += String(rtc.getDay());
  dataString +="/";
  dataString += String(rtc.getMonth());
  dataString +="/";
  dataString += String(rtc.getYear());
  dataString +=",";
  dataString += String(rtc.getHours());
  dataString +=":";
  dataString += String(rtc.getMinutes());
  dataString +=":";
  dataString += String(rtc.getSeconds());
  dataString +=",";

  // read three sensors and append to the string:
  for (int analogPin = 0; analogPin < 3; analogPin++) {
    float sensor = result[analogPin];
    dataString += String(sensor);
    if (analogPin < 2) {
      dataString += ",";
    }
  }

  // open the file. note that only one file can be open at a time,
  // so you have to close this one before opening another.
  File dataFile = SD.open("datalog.txt", FILE_WRITE);

  // if the file is available, write to it:
  if (dataFile) {
    dataFile.println(dataString);
    dataFile.close();
    // print to the serial port too:
    Serial.println(dataString);
  }
  // if the file isn't open, pop up an error:
  else {
    Serial.println("error opening datalog.txt");
  }
  delay(3000);
}

const byte CO2Command[] = {0xFE, 0X04, 0X00, 0X03, 0X00, 0X01, 0XD5, 0XC5};
byte Response[] = {0, 0, 0, 0, 0, 0, 0};
unsigned long val;

void setup() {
  Serial1.begin(9600);//Brancher le S8 sur RX1 et TX1
  Serial.begin(9600);
  delay(100);
  Serial.print("start");
}

void loop() {
  Serial1.write(CO2Command, 8);
  Serial1.readBytes(Response, 7);
  while (Serial1.available()) Serial1.read();//vidage du buffer
  if (Response[0] == 254) {
    val = Response[3] * 256 + Response[4];
    Serial.println(val);
  }
  else Serial.println("erreur CO2");
  delay(2000);
}

#include <SD.h>
#include <RTCZero.h>

const int chipSelect = SDCARD_SS_PIN;

/* Create an rtc object */
RTCZero rtc;
const byte seconds = 0;
const byte minutes = 0;
const byte hours = 16;
const byte day = 15;
const byte month = 6;
const byte year = 18;

const byte CO2Command[] = {0xFE, 0X04, 0X00, 0X03, 0X00, 0X01, 0XD5, 0XC5};
byte Response[] = {0, 0, 0, 0, 0, 0, 0};
unsigned long val;

void setup() {
  Serial1.begin(9600);//Brancher le S8 sur RX1 et TX1
  Serial.begin(9600);
  delay(100);
  Serial.print("start");
  while (!Serial)
   {
    ; // wait for serial port to connect. Needed for native USB port only
}

  Serial.print("Initializing SD card...");

  // see if the card is present and can be initialized:
  if (!SD.begin(chipSelect)) {
    Serial.println("Card failed, or not present");
    // don't do anything more:
    while (1);
  }
  Serial.println("card initialized.");

  rtc.begin(); // initialize RTC

  rtc.setHours(hours);
  rtc.setMinutes(minutes);
  rtc.setSeconds(seconds);
  rtc.setDay(day);
  rtc.setMonth(month);
  rtc.setYear(year);
}

void loop() {

  Serial.print(rtc.getDay());
  Serial.print("/");
  Serial.print(rtc.getMonth());
  Serial.print("/");
  Serial.print(rtc.getYear());
  Serial.print(" ");
  Serial.print(rtc.getHours());
  Serial.print(":");
  Serial.print(rtc.getMinutes());
  Serial.print(":");
  Serial.print(rtc.getSeconds());
  Serial.println();
  // make a string for assembling the data to log:
  String dataString = "";


  Serial1.write(CO2Command, 8);
  Serial1.readBytes(Response, 7);
  while (Serial1.available()) Serial1.read();//vidage du buffer
  if (Response[0] == 254) {
    val = Response[3] * 256 + Response[4];
    Serial.println(val);
  }
  else Serial.println("erreur CO2");
  delay(1000);

  dataString += String(rtc.getDay());
  dataString +="/";
  dataString += String(rtc.getMonth());
  dataString +="/";
  dataString += String(rtc.getYear());
  dataString +=",";
  dataString += String(rtc.getHours());
  dataString +=":";
  dataString += String(rtc.getMinutes());
  dataString +=":";
  dataString += String(rtc.getSeconds());
  dataString += "   CO2 :";
  dataString += String(val);

  // open the file. note that only one file can be open at a time,
  // so you have to close this one before opening another.
  File dataFile = SD.open("datalog.txt", FILE_WRITE);

  // if the file is available, write to it:
  if (dataFile) {
    dataFile.println(dataString);
    dataFile.close();
    // print to the serial port too:
    Serial.println(dataString);
  }
  // if the file isn't open, pop up an error:
  else {
    Serial.println("error opening datalog.txt");
  }
  delay(1000);
}

// Inclure le code de la bibliothèque:
//#include <LiquidCrystal_I2C.h>
// Initialiser la bibliothèque avec les dimensions de l'interface
//LiquidCrystal_I2C lcd(0x27, 20, 4);

// Capteur MQ-9
// réglage de la broche de connexion
#define pinA A0


// variables de mesure
float sensor_volt;
float RS_air;
float R0;
float sensorValue;
float RS_gas;
float ratio;

unsigned long currentTime = 0;
unsigned long previousTime = 0;
boolean StabilisationMQ9;
char buffer[20] = "";
char buffer2[5] = "";
char buffer3[5] = "";

void setup() {
  Serial.begin(9600);
  //pinMode(ledPinVert, OUTPUT);
  //digitalWrite(ledPinVert, LOW);
  //pinMode(ledPinRouge, OUTPUT);
  //digitalWrite(ledPinRouge, LOW);
  // Initialisation de l'interface LCD
  //lcd.init();
  // Active le rétro-éclairage du LCD
  //lcd.backlight();
}

void loop() {
  currentTime = millis();
  //Programme stabilisation
  if (StabilisationMQ9 == 0) {
    if ((currentTime - previousTime) > 600000) {
      StabilisationMQ9 = 1;
      //previousTime = currentTime;
    }
    // boucle pour récupérer 100 mesures
    sensorValue = 0;
    for (int x = 0; x < 100; x++) {
      // à chaque exécution on ajoute une nouvelle valeur à la variable
      // de l'entrée analogique
      sensorValue = sensorValue + analogRead(pinA);
      delay(1);
    }
    // obtient la valeur moyenne
    sensorValue = sensorValue / 100.0;
    // calcul de la valeur de la tension d'entrée
    sensor_volt = sensorValue / 1024 * 5.0;
    // calcul de la résistance de l'air
    RS_air = (5.0 - sensor_volt) / sensor_volt;
    // calcul de la constante R0 - ratio 9.9:1 lu sur le graphique
    R0 = RS_air / 9.9;
    // affichage des données mesurées sur LCD
    //lcd.setCursor(0, 0);
    //lcd.print("--Stabilisation--MQ9");
    //dtostrf(sensor_volt, 2, 2, buffer2);
    sprintf(buffer, "Tens. entree: %5sV", buffer2);
    //lcd.setCursor(0, 1);
    //lcd.print(buffer);
    //dtostrf(R0, 4, 2, buffer2);
    sprintf(buffer, "Constante R0 : %5s", buffer2);
    //lcd.setCursor(0, 2);
    //lcd.print(buffer);
    // affichage des données mesurées sur console
    Serial.println("Stabilisation en cours");
    Serial.print("Tension d'entrée: ");
    Serial.print(sensor_volt);
    Serial.println("V");
    Serial.print("Constante R0 : ");
    Serial.println(R0);
    Serial.println("------------------");
    //digitalWrite(ledPinVert, HIGH);
    delay(500);
    //digitalWrite(ledPinVert, LOW);
    delay(500);
  }
  //Programme mesure
  else {
    // lire la valeur de la broche analogique
    sensorValue = analogRead(pinA);
    // calcule la tension d'entrée
    sensor_volt = (float)sensorValue / 1024 * 5.0;
    // calcul de la résistance actuelle
    RS_gas = (5.0 - sensor_volt) / sensor_volt;
    // calcule le rapport de lecture du graphique
    ratio = RS_gas / R0;
    // affichage des données mesurées sur LCD
    //lcd.setCursor(0, 0);
    //lcd.print("  -- Mesure --   MQ9");
    //dtostrf(sensor_volt, 2, 2, buffer2);
    sprintf(buffer, "Tens. entree: %5sV", buffer2);
    //lcd.setCursor(0, 1);
    //lcd.print(buffer);
    //dtostrf(R0, 5, 2, buffer2);
    //dtostrf(ratio, 5, 1, buffer3);
    sprintf(buffer, "R0:%5s Rs/R0:%5s", buffer2, buffer3);
    //lcd.setCursor(0, 2);
    //lcd.print(buffer);
    // affichage des données mesurées sur console
    Serial.println("Stabilisation ok");
    Serial.print("Tension d'entrée: ");
    Serial.println(sensor_volt);
    Serial.print("Constante R0 : ");
    Serial.println(R0);
    Serial.print("Rapport de Rs/R0: ");
    Serial.println(ratio);
    Serial.println("------------------ ");
    // si le ratio est inférieur à 1,5,
    // on calcule l'estimation de la concentration en CO
    if (ratio < 1.5) {
      //digitalWrite(ledPinRouge, HIGH);
      //digitalWrite(ledPinVert, LOW);
      // recalcul des données chargées, de la plage 0-700
      // à la concentration 200-10000
      ratio = ratio * 100;
      int ppm = map(ratio, 150, 79, 200, 1000);
      sprintf(buffer, "Alarme CO : %d ppm", ppm);
      //lcd.setCursor(0, 3);
      //lcd.print(buffer);
      Serial.print("Concentration approximative de CO : ");
      Serial.print(ppm);
      Serial.println(" ppm.");
    } else {
      //digitalWrite(ledPinRouge, LOW);
     // digitalWrite(ledPinVert, HIGH);
      //lcd.setCursor(0, 3);
      //lcd.print("                    ");
    }
    Serial.println();
    delay(1000);
  }
}

// Capteur MQ-9
// réglage de la broche de connexion
#define pinA A0
#include <RTCZero.h>
#include <SD.h>

const int chipSelect = SDCARD_SS_PIN;

/* Create an rtc object */
RTCZero rtc;
const byte seconds = 0;
const byte minutes = 0;
const byte hours = 7;
const byte day = 15;
const byte month = 6;
const byte year = 18;

// variables de mesure
float sensor_volt;
float RS_air;
float R0;
float sensorValue;
float RS_gas;
float ratio;

unsigned long currentTime = 0;
unsigned long previousTime = 0;
boolean StabilisationMQ9;
char buffer[20] = "";
char buffer2[5] = "";
char buffer3[5] = "";

void setup() {
  Serial.begin(9600);
  while (!Serial)
   {
    ;
}

  Serial.print("Initializing SD card...");

  // see if the card is present and can be initialized:
  if (!SD.begin(chipSelect)) {
    Serial.println("Card failed, or not present");
    // don't do anything more:
    while (1);
  }
  Serial.println("card initialized.");

  rtc.begin(); // initialize RTC

  rtc.setHours(hours);
  rtc.setMinutes(minutes);
  rtc.setSeconds(seconds);
  rtc.setDay(day);
  rtc.setMonth(month);
  rtc.setYear(year);
}
void loop() {

  Serial.print(rtc.getDay());
  Serial.print("/");
  Serial.print(rtc.getMonth());
  Serial.print("/");
  Serial.print(rtc.getYear());
  Serial.print(" ");
  Serial.print(rtc.getHours());
  Serial.print(":");
  Serial.print(rtc.getMinutes());
  Serial.print(":");
  Serial.print(rtc.getSeconds());
  Serial.println();
  // make a string for assembling the data to log:
  String dataString = "";
  currentTime = millis();
  //Programme stabilisation
  if (StabilisationMQ9 == 0) {
    if ((currentTime - previousTime) > 600000) {
      StabilisationMQ9 = 1;
      //previousTime = currentTime;
    }
    // boucle pour récupérer 100 mesures
    sensorValue = 0;
    for (int x = 0; x < 100; x++) {
      // à chaque exécution on ajoute une nouvelle valeur à la variable
      // de l'entrée analogique
      sensorValue = sensorValue + analogRead(pinA);
      delay(1);
    }
    // obtient la valeur moyenne
    sensorValue = sensorValue / 100.0;
    // calcul de la valeur de la tension d'entrée
    sensor_volt = sensorValue / 1024 * 5.0;
    // calcul de la résistance de l'air
    RS_air = (5.0 - sensor_volt) / sensor_volt;
    // calcul de la constante R0 - ratio 9.9:1 lu sur le graphique
    R0 = RS_air / 9.9;
    
    sprintf(buffer, "Tens. entree: %5sV", buffer2);

    sprintf(buffer, "Constante R0 : %5s", buffer2);
 
    Serial.println("Stabilisation en cours");
    Serial.print("Tension d'entrée: ");
    Serial.print(sensor_volt);
    Serial.println("V");
    Serial.print("Constante R0 : ");
    Serial.println(R0);
    Serial.println("------------------");
    delay(500);
    delay(500);
  }
  //Programme mesure
  else {
    // lire la valeur de la broche analogique
    sensorValue = analogRead(pinA);
    // calcule la tension d'entrée
    sensor_volt = (float)sensorValue / 1024 * 5.0;
    // calcul de la résistance actuelle
    RS_gas = (5.0 - sensor_volt) / sensor_volt;
    // calcule le rapport de lecture du graphique
    ratio = RS_gas / R0;
    // affichage des données mesurées sur LCD
    //lcd.setCursor(0, 0);
    //lcd.print("  -- Mesure --   MQ9");
    //dtostrf(sensor_volt, 2, 2, buffer2);
    sprintf(buffer, "Tens. entree: %5sV", buffer2);
    //lcd.setCursor(0, 1);
    //lcd.print(buffer);
    //dtostrf(R0, 5, 2, buffer2);
    //dtostrf(ratio, 5, 1, buffer3);
    sprintf(buffer, "R0:%5s Rs/R0:%5s", buffer2, buffer3);
    //lcd.setCursor(0, 2);
    //lcd.print(buffer);
    // affichage des données mesurées sur console
    Serial.println("Stabilisation ok");
    Serial.print("Tension d'entrée: ");
    Serial.println(sensor_volt);
    Serial.print("Constante R0 : ");
    Serial.println(R0);
    Serial.print("Rapport de Rs/R0: ");
    Serial.println(ratio);
    Serial.println("------------------ ");
  }

    // si le ratio est inférieur à 1,5,
    // on calcule l'estimation de la concentration en CO
    //if (ratio < 1.5) {

      // recalcul des données chargées, de la plage 0-700
      // à la concentration 200-10000
      //ratio = ratio * 100;
      //int ppm = map(ratio, 150, 79, 200, 1000);
      //sprintf(buffer, "Alarme CO : %d ppm", ppm);
 
      //Serial.print("Concentration approximative de CO : ");
      //Serial.print(ppm);
      //Serial.println(" ppm.");
      
    //} else {
                //   ;
    //}
    //Serial.println();
  dataString += String(rtc.getDay());
  dataString +="/";
  dataString += String(rtc.getMonth());
  dataString +="/";
  dataString += String(rtc.getYear());
  dataString +=",";
  dataString += String(rtc.getHours());
  dataString +=":";
  dataString += String(rtc.getMinutes());
  dataString +=":";
  dataString += String(rtc.getSeconds());
  dataString += "sensor_volt :";
  dataString += String(sensor_volt);
  dataString += "V---";
  dataString += "R0:";
  dataString += String(R0);
  dataString += "---ratio:";
  dataString += String(ratio);

  File dataFile = SD.open("datalog.txt", FILE_WRITE);
// if the file is available, write to it:
  if (dataFile) {
    dataFile.println(dataString);
    dataFile.close();
    // print to the serial port too:
    Serial.println(dataString);
  }
  // if the file isn't open, pop up an error:
  else {
    Serial.println("error opening datalog.txt");

  }
    delay(1000);
  }