Capteur de CO2
En temps de covid, mesurer le taux de CO2 dans l'air d'une pièce peut-être un bon indicateur de la nécessité d'aération.
Sommaire
de quoi s'agit-il ?
Avant toute chose
Il faut saluer et remercier le travail effectué par les personnes qui ont réalisé le site Nousaerons.fr (cliquez sur l'image pour y aller !).
D'une manière générale nous citons toutes les sources mobilisées pour réaliser cette page.
Taux de CO2 et qualité de l'air intérieur
Texte tiré de https://projetco2.fr/pourquoi-mesurer-co2
Le lien entre la qualité de l'air d'une pièce et la concentration en CO2 est donnée par les valeurs caractéristiques suivantes :
- < 800 ppm : correspond à une qualité d'air excellente selon la norme NF EN 13779 et c'est une recommandation du Haut Conseil de la Santé publique. Cela constitue donc une valeur "cible" à atteindre.
- entre 800 et 1000 ppm : correspond à une qualité d'air moyenne selon la norme NF EN 13779
- entre 1000 et 1500 ppm : correspond à une qualité d'air modérée selon la norme NF EN 13779. Cela correspond à des valeurs trop élevées en contexte Covid-19.
- > 1500 ppm : correspond à une qualité d'air basse selon la norme NF EN 13779. Cela correspond à des valeurs beaucoup trop élevées en contexte Covid-19.
Dans un lieu confiné, il n'est pas rare de dépasser le premier seuil au bout de quelques minutes. C'est le cas dans certaines salles de réunions ou salles de classes mal ventilées.
Attention, il existe des situations spécifiques pour lesquelles les seuils donnés ci-dessus ne sont pas pertinents :
- Ces seuils ne sont pas pertinents dans les salles dans lesquels un recyclage partiel de l'air est assuré par un dispositif de filtration de type HEPA. Cette solution de purification de l'air en milieu clos par filtration doit faire l'objet d'une étude spécifique
- Ces seuils sont donnés pour un taux en "plein air" d'environ 400 à 420 ppm qui sert de référence. Ce taux peut monter dans les grandes métropoles jusqu'à 500 ppm voire 600 ppm lors des pics de pollution. Ces valeurs élevées sont usuellement mesurées le matin. Il convient alors d'ajuster les seuils à surveiller à l'augmentation constatée du taux "plein air". Par exemple, si le taux de CO2 mesuré en plein air est de 500 ppm, il faut ajouter 100 ppm à tous les seuils proposés ci-dessus.
Hors contexte covid-19, la mesure du CO2 et la vérification de la qualité de l'air reste importante. Une bonne aération diminue les risques de maladie respiratoire. D'autre part, une concentration en CO2 supérieure à 1 000 ppm entraîne une diminution (réversible) des facultés cognitives.
Ainsi les recommandation pour notre capteur :
- rouge si CO2 >1000 ppm. au dessus de 1000 ppm c'est trop
- orange si 1000 ppm > CO2 > 800 ppm. Entre 800 ppm et 1000 ppm de CO2, il faut aérer.
- vert si CO2 < 800 ppm. Sous les 800 ppm la qualité de l'air est excellente (avec un masques)
Pour info : le taux de CO2 atmosphérique était de 400 ppm en 2013, il a passé les 415 ppm en 2019, il était de 283 ppm en 1839.
quel capteur choisir ?
Le SenseAir S8 LP
le capteur SenseAir S8 existe en plusieurs versions :
- la classique : S8 LP - préférer celui-ci !!
- la moins cher S8-4B (attention le capteur n'effectue une mesure que toutes les 20 secondes).
Pourquoi ?
C'est une technologie fiable : analyse de l'air par lumière infra-rouge (NDIR - Non dispersive InfraRed)
- deux faisceaux de lumière
- un qui n'est pas absorbé par les gaz de l'air sert de référence.
- un qui n'est absorbé que par le CO2
la différence permet de calculer la concentration en CO2 en ppm (partie par million de volume).
- 10 000 ppm = 1%
- la concentration normale en CO2 est de 415 ppm soient environ 0,04%
C'est un capteur qui est recommandé par l'ANSES.
calibration
Nécessaire de temps en temps si on constate une dérive (pour cela placer son capteur à l'extérieur pendant 15 minutes, si il ne donne pas 400 à 415 ppm, il faudra procéder à la calibration).
Comment faire ?
Avant de commencer l'étalonnage manuel, le capteur doit être à environ 400 ppm pendant quelques minutes (un minimum de 15 minutes) pour que le capteur se stabilise.
La procédure est très simple :
- Laissez le capteur fonctionner à l'extérieur pendant au moins 15 minutes.
- Connectez la broche bCAL_in à GND pendant plus de 4 secondes et moins de 8 secondes.
- Laissez le capteur à l'extérieur pendant environ 5 minutes pour qu'il termine son étalonnage et se stabilise.
- C'est fait. Le capteur va considérer que la concentration actuelle est de 400 ppm.
- laissez 5 minutes à l'extérieur pour contrôler les mesures.
Il est important de ne pas laisser la broche bCAL_in connectée à GND pendant plus de 8 secondes, car si les 13 secondes sont dépassées, le capteur démarre un mode de calibration différent, qui n'est pas celui qui nous intéresse (c'est un mode de calibration avec une concentration de 0 ppm de CO2, pour lequel il faut immerger le capteur dans l'azote, par exemple).
Source : https://emariete.com/en/meter-co2-esp8266-nodemcu-sensor-senseair-s8/
un boitier
Un boitier qui signale s'il faut aérer avec des led.
Accès précis à la mesure
Le boitier émet un réseau wifi ouvert permettant de s'y connecter et de rejoindre un site web local qui indique le taux de CO2 mesuré.
Un QRcode peut être utilisé pour rejoindre le site web à l'adresse 192.168.4.1
le QRCode
Affichage sur un smartphone
Montage électronique Schéma Fritzing
Matériel :
- un D1 mini (esp8266).
- un shield batterie
- une batterie 18650
- un capteur SenseAir S8
- 3 led (rouge, orange, verte) de 10mm de diamètre (des grosses).
- 3 résistances de 220 ohms (rouge-rouge-marron).
- 1 interrupteur
- du fil électrique
STL du Boitier
Ce stl est "grand" pour pouvoir être imprimé avec une imprimante 3D bas de gamme (qui bave un peu, quoi).
téléchargez le zip du fichier Fusion 360 du boitier
Fichier:CapteurCO2-FaceArriere.stl
Fichier:CapteurCO2-FaceAvant.stl
montage avec Arduino
Programme pour allumer des leds en fonction de la qualité de l'air
BUG POSSIBLES
des utilisateurs ont constaté un problème d’attribution de broche.
Solutions :
- soit modifier la bibliothèque,
- soit dans le setup attribuer les GPIO au capteur et pas les numéros de broche monCapteur.CO2_Init(2,0) à la place de monCapteur.CO2_Init(D4,D3)(voir le schéma du D1 mini).
ATTENTION AUX BIBLIOTHEQUES ARDUINO
N'oubliez pas d'installer la bibliothèque "Airgradient", ainsi que "ESPAsyncWebServer" à partir du gestionnaire de bibliothèque.
Toutes les info sur les bibliothèques :
- Airgradient : https://www.arduino.cc/reference/en/libraries/airgradient-air-quality-sensor/
- ESPAsyncWebServer : https://github.com/me-no-dev/ESPAsyncWebServer
pour l'ESP8266 (le D1 mini) il faut aussi la bibliothèque [ESPAsyncTCP](https://github.com/me-no-dev/ESPAsyncTCP)
le code
1 ////////////////////
2 // Capteur de CO2 //
3 ////////////////////
4 /*
5 * Proposé dans le cadre de PAPIFAB, un atelier mensuel à l'initiative de la ville Brest animé par les petits débrouillards.
6 *
7 * D1 mini
8 BROCHAGE
9 _________________
10 / D1 mini \
11 |[ ]RST TX[ ]|
12 |[ ]A0 -GPIO RX[ ]|
13 |[ ]D0-16 5-D1[ ]|
14 |[ ]D5-14 4-D2[ ]|
15 Led Rouge |[X]D6-12 0-D3[X]| -> UART_RxD
16 Led Orange |[X]D7-13 2-D4[X]| -> UART_TxD
17 Led Verte |[X]D8-15 GND[X]| -> G0
18 |[ ]3V3 . 5V[X]| -> G+
19 | +---+ |
20 |_______|USB|_______|
21
22 ________________________
23 | |° ° ° ° ° °| | |
24 +5V <- G+ |[X]| ° ° ° ° °/ |[ ]| DVCC_out
25 GND <- G0 |[X]|° ° ° ° °/ |[X]| UART_RxD -> D3
26 Alarm_OC |[ ]|_°_°_°_°| |[X]| UART_TxD -> D4
27 PWM 1Khz |[ ]| |[ ]| UART_R/T
28 | | SenseAir® S8 |[ ]| bCAL_in/CAL
29 |___|________________|___|
30 Matériel :
31 - des fils dupont.
32 - un capteur SenseAir® S8
33 - Un D1 mini
34 - ...
35
36 ___
37 / ___ \
38 |_| | |
39 /_/
40 _ ___ _
41 |_| |___|_| |_
42 ___|_ _|
43 |___| |_|
44 Les petits Débrouillards 2021- CC-By-Sa http://creativecommons.org/licenses/by-nc-sa/3.0/
45
46 Ce code est inspiré du code pour le "AirGradient DIY Air Quality Sensor" avec un Microcontroller ESP8266.
47 Pour plus d'infos, visitez https://www.airgradient.com/diy/
48 MIT License
49
50 Ce projet se nourrit également du travail de Nous aérons : https://nousaerons.fr/makersco2/
51 */
52
53 #include <AirGradient.h> //appel de la bibliothèque "AirGradient.h" qui gère le capteur
54 AirGradient monCapteur = AirGradient(); // création de "monCapteur"
55
56 int CO2 = 400; // 400ppm c'est la valeur du CO2 dans l'air extérieur
57 int ledR = 12; // broche D6 sur le GPIO 12
58 int ledO = 13; // broche D7 sur le GPIO 13
59 int ledV = 15; // broche D8 sur le GPIO 15
60 long temps; // cette variable sert à compter le temps
61 int brillance = 0;
62 int pas = 10;
63
64 void mesure () { // Cette fonction appelle le capteur et lui demande une mesure
65 CO2 = monCapteur.getCO2_Raw();
66 Serial.print("Taux de C02 : ");
67 Serial.print(CO2);
68 Serial.print(" ppm - ");
69 }
70
71 void affichage (){ // Cette fonction allume les leds en fonction du taux de CO2 mesuré
72 /* Seuil recommandés dans un contexte ou l'air n'est pas filtré :
73 * ROUGE si CO2 > 1000ppm. Au dessus de 1000ppm c'est trop, il est est urgent d'aérer !
74 * ORANGE si 1000ppm > CO2 > 800ppm. Entre 800ppm et 1000ppm de CO2, il faut commencer à aérer.
75 * VERT si CO2 < 800ppm. Sous les 800ppm, la qualité de l'air est excellente (avec un masques)
76 * dans tous les cas, respectez les gestes barrières.
77 * Source : Haut Conseil pour la Santé Publique, avis du 22 novembre 2020.
78 */
79 if (CO2 < 800){ // La qualité de l'air est excellente (avec un masques)
80 digitalWrite(ledV,HIGH);
81 digitalWrite(ledO,LOW);
82 digitalWrite(ledR,LOW);
83 Serial.println("La qualité de l'air est excellente");
84 }
85 else if (CO2 > 800 && CO2 < 1000){ // Il faut commencer à aérer.
86 digitalWrite(ledV,LOW);
87 digitalWrite(ledO,HIGH);
88 digitalWrite(ledR,LOW);
89 Serial.println("Il faut commencer à aérer.");
90 }
91 else if (CO2 > 1000){ // C'est trop, il est est urgent d'aérer !
92 digitalWrite(ledV,LOW);
93 digitalWrite(ledO,LOW);
94 digitalWrite(ledR,HIGH);
95 Serial.println("C'est trop ! il est est urgent d'aérer !");
96 }
97 }
98
99 void demarrage (){ // Procédure de test des leds (juste pour le fun, c'est pas indispensable)
100 for (int i=0; i<3; i++) { // boucle qui les allumes les unes après les autres
101 digitalWrite(ledV,LOW);
102 digitalWrite(ledO,LOW);
103 digitalWrite(ledR,HIGH);
104 delay(100);
105 digitalWrite(ledV,LOW);
106 digitalWrite(ledO,HIGH);
107 digitalWrite(ledR,LOW);
108 delay(100);
109 digitalWrite(ledV,HIGH);
110 digitalWrite(ledO,LOW);
111 digitalWrite(ledR,LOW);
112 delay(100);
113 }
114
115 for (int i=0; i<3; i++) { // Boucle qui les allume toutes en un fondu enchainé.
116 for (int j=0; j<30; j++){
117 analogWrite(ledV,brillance);
118 analogWrite(ledO,brillance);
119 analogWrite(ledR,brillance);
120 brillance = brillance + pas ;
121 if (brillance <= 0 || brillance >= 130) {
122 pas = -pas;
123 }
124 delay(30);
125 }
126 }
127 digitalWrite(ledV,LOW); // on éteint tout
128 digitalWrite(ledO,LOW);
129 digitalWrite(ledR,LOW);
130 }
131
132 void setup(){
133 Serial.begin(9600); // ouverture du port série
134 monCapteur.CO2_Init(); // initialisation de "monCapteur"
135
136 pinMode(ledR, OUTPUT); // broches configurée en sorties
137 pinMode(ledO, OUTPUT);
138 pinMode(ledV, OUTPUT);
139
140 temps = millis(); // on enregistre le temps
141
142 demarrage(); // procédure de test des leds au démarrage
143 }
144
145 void loop(){
146 if((millis() - temps) > 5000){ // au bout de 5 secondes :
147 mesure (); // on mesure le taux de CO2
148 affichage (); // on affiche le résultat
149 temps = millis(); // on remet le compteur à zero.
150 }
151 }
Programme qui allume les led et diffuse un réseau wifi avec la mesure
1 //////////////////////
2 // Capteur de CO2 //
3 // avec affiche web //
4 //////////////////////
5 /*
6 * Proposé dans le cadre de PAPIFAB, un atelier mensuel à l'initiative de la ville Brest animé par les petits débrouillards.
7 *
8 * D1 mini
9 BROCHAGE
10 _________________
11 / D1 mini \
12 |[ ]RST TX[ ]|
13 |[ ]A0 -GPIO RX[ ]|
14 |[ ]D0-16 5-D1[ ]|
15 |[ ]D5-14 4-D2[ ]|
16 Led Rouge |[X]D6-12 0-D3[X]| -> UART_RxD
17 Led Orange |[X]D7-13 2-D4[X]| -> UART_TxD
18 Led Verte |[X]D8-15 GND[X]| -> G0
19 |[ ]3V3 . 5V[X]| -> G+
20 | +---+ |
21 |_______|USB|_______|
22
23 ________________________
24 | |° ° ° ° ° °| | |
25 +5V <- G+ |[X]| ° ° ° ° °/ |[ ]| DVCC_out
26 GND <- G0 |[X]|° ° ° ° °/ |[X]| UART_RxD -> D3
27 Alarm_OC |[ ]|_°_°_°_°| |[X]| UART_TxD -> D4
28 PWM 1Khz |[ ]| |[ ]| UART_R/T
29 | | SenseAir® S8 |[ ]| bCAL_in/CAL
30 |___|________________|___|
31 Matériel :
32 - des fils dupont.
33 - un capteur SenseAir® S8
34 - Un D1 mini
35 - ...
36
37 ___
38 / ___ \
39 |_| | |
40 /_/
41 _ ___ _
42 |_| |___|_| |_
43 ___|_ _|
44 |___| |_|
45 Les petits Débrouillards 13 août 2021- CC-By-Sa http://creativecommons.org/licenses/by-nc-sa/3.0/
46
47 Ce code est inspiré du code pour le "AirGradient DIY Air Quality Sensor" avec un Microcontroller ESP8266.
48 Pour plus d'infos, visitez https://www.airgradient.com/diy/
49 MIT License
50
51 Ce projet se nourrit également du travail de Nous aérons : https://nousaerons.fr/makersco2/
52 */
53 // Appel des bibliothèques
54 #include <ESP8266WiFi.h>
55 #include <ESPAsyncWebServer.h>
56 #include <AirGradient.h> //appel de la bibliothèque "AirGradient.h" qui gère le capteur
57 AirGradient monCapteur = AirGradient(); // création de "monCapteur"
58
59 const char* ssid = "Taux de CO2";
60 const char* password = "";
61
62 // Creation du serveur AsyncWebServer sur le port 80
63 AsyncWebServer serveurCO2(80);
64
65 int CO2 = 400; // 400ppm c'est la valeur du CO2 dans l'air extérieur
66 int ledV = 15; // broche D8 sur le GPIO 15
67 int ledO = 13; // broche D7 sur le GPIO 13
68 int ledR = 12; // broche D6 sur le GPIO 12
69
70 long temps; // cette variable sert à compter le temps
71 int brillance = 0;
72 int pas = 10;
73
74 // page web "index.html"
75 const char index_html[] PROGMEM = R"rawliteral(
76 <!DOCTYPE HTML><html>
77 <head>
78 <meta name="viewport" content="width=device-width, initial-scale=1">
79 <style>
80 html {
81 font-family: Arial;
82 display: inline-block;
83 margin: 0px auto;
84 text-align: center;
85 }
86 h2 { font-size: 3.0rem; }
87 p { font-size: 3.0rem; }
88 </style>
89 </head>
90 <body>
91 <h2>Taux de CO2 mesuré</h2>
92 <p>
93 <span>L'air ambiant contient</span>
94 <span>%TAUXCO2%</span>
95 <span>ppm de CO2</span>
96 </p>
97 </body>
98 <script>
99 setInterval(function ( ) {
100 var xhttp = new XMLHttpRequest();
101 xhttp.onreadystatechange = function() {
102 if (this.readyState == 4 && this.status == 200) {
103 document.getElementById("TauxDeCO2").innerHTML = this.responseText;
104 }
105 };
106 xhttp.open("GET", "/TauxDeCO2", true);
107 xhttp.send();
108 }, 10000 ) ;
109
110 </script>
111 </html>)rawliteral";
112
113 // Renvooe les données du capteur de CO2
114 String processor(const String& var){
115 if(var == "TAUXCO2"){
116 return String(CO2);
117 }
118 return String();
119 }
120
121 void mesure () { // Cette fonction appelle le capteur et lui demande une mesure
122 CO2 = monCapteur.getCO2_Raw();
123 Serial.print("Taux de C02 : ");
124 Serial.print(CO2);
125 Serial.print(" ppm - ");
126 }
127
128 void affichage (){ // Cette fonction allume les leds en fonction du taux de CO2 mesuré
129 /* Seuil recommandés dans un contexte ou l'air n'est pas filtré :
130 * ROUGE si CO2 > 1000ppm. Au dessus de 1000ppm c'est trop, il est est urgent d'aérer !
131 * ORANGE si 1000ppm > CO2 > 800ppm. Entre 800ppm et 1000ppm de CO2, il faut commencer à aérer.
132 * VERT si CO2 < 800ppm. Sous les 800ppm, la qualité de l'air est excellente (avec un masques)
133 * dans tous les cas, respectez les gestes barrières.
134 * Source : Haut Conseil pour la Santé Publique, avis du 22 novembre 2020.
135 */
136 if (CO2 < 800){ // La qualité de l'air est excellente (avec un masques)
137 digitalWrite(ledV,HIGH);
138 digitalWrite(ledO,LOW);
139 digitalWrite(ledR,LOW);
140 Serial.println("La qualité de l'air est excellente");
141 }
142 else if (CO2 > 800 && CO2 < 1000){ // Il faut commencer à aérer.
143 digitalWrite(ledV,LOW);
144 digitalWrite(ledO,HIGH);
145 digitalWrite(ledR,LOW);
146 Serial.println("Il faut commencer à aérer.");
147 }
148 else if (CO2 > 1000){ // C'est trop, il est est urgent d'aérer !
149 digitalWrite(ledV,LOW);
150 digitalWrite(ledO,LOW);
151 digitalWrite(ledR,HIGH);
152 Serial.println("C'est trop ! il est est urgent d'aérer !");
153 }
154 }
155
156 void demarrage (){ // Procédure de test des leds (juste pour le fun, c'est pas indispensable)
157 for (int i=0; i<3; i++) { // boucle qui les allumes les unes après les autres
158 digitalWrite(ledV,LOW);
159 digitalWrite(ledO,LOW);
160 digitalWrite(ledR,HIGH);
161 delay(100);
162 digitalWrite(ledV,LOW);
163 digitalWrite(ledO,HIGH);
164 digitalWrite(ledR,LOW);
165 delay(100);
166 digitalWrite(ledV,HIGH);
167 digitalWrite(ledO,LOW);
168 digitalWrite(ledR,LOW);
169 delay(100);
170 }
171
172 for (int i=0; i<3; i++) { // Boucle qui les allume toutes en un fondu enchainé.
173 for (int j=0; j<30; j++){
174 analogWrite(ledV,brillance);
175 analogWrite(ledO,brillance);
176 analogWrite(ledR,brillance);
177 brillance = brillance + pas ;
178 if (brillance <= 0 || brillance >= 130) {
179 pas = -pas;
180 }
181 delay(30);
182 }
183 }
184 digitalWrite(ledV,LOW); // on éteint tout
185 digitalWrite(ledO,LOW);
186 digitalWrite(ledR,LOW);
187 }
188
189 void setup(){
190 Serial.begin(9600); // ouverture de la communication série
191 monCapteur.CO2_Init(); // initialisation de "monCapteur"
192
193 pinMode(ledR, OUTPUT); // broches configurée en sorties
194 pinMode(ledO, OUTPUT);
195 pinMode(ledV, OUTPUT);
196
197 temps = millis(); // on enregistre le temps
198
199 demarrage(); // procédure de test des leds au démarrage
200
201 Serial.print("Réglage du point d'accès …");
202 WiFi.softAP(ssid);
203
204 IPAddress IP = WiFi.softAPIP();
205 Serial.print("addresse IP du point d'accès: ");
206 Serial.println(IP);
207
208 // Chemin vers le serveur web
209 serveurCO2.on("/", HTTP_GET, [](AsyncWebServerRequest *request){
210 request->send_P(200, "text/html", index_html, processor);
211 });
212 serveurCO2.on("/TauxDeCO2", HTTP_GET, [](AsyncWebServerRequest *request){
213 request->send_P(200, "text/plain", String(CO2).c_str());
214 });
215
216 // démarrage du serveur
217 serveurCO2.begin();
218 }
219
220 void loop(){
221 if((millis() - temps) > 5000){ // au bout de 5 secondes : (ajuster le temps !!)
222 mesure (); // on mesure le taux de CO2
223 affichage (); // on affiche le résultat
224 temps = millis(); // on remet le compteur à zero.
225 }
226 }
Programme pour publier sur thingspeak
A faire !
Ressources et inspirations
voir : https://www.arduino.cc/reference/en/libraries/airgradient-air-quality-sensor/ Capteurs à disposition : Senseair S8
- Voir https://www.airgradient.com/diy/
- Tuto vidéo : https://www.youtube.com/watch?v=n059hQpybsE
- Achat du capteur SenseAir S8 : chez Ali ou https://www.amazon.fr/infrarouge-Communication-400%E2%80%912000PPM-environnements-concentration/dp/B08N4LNQFM/
- pas mal ici : https://wiki.lafabriquedesmobilites.fr/wiki/Capteur_d%C3%A9tecteur_CO2
- https://wikifab.org/wiki/Afficheur_CO2
- https://ducotedelascience.org/
- https://nousaerons.fr/makersco2/
- https://projetco2.fr/pourquoi-mesurer-co2
Rien a voir
il faut tester ça ! http://hebergement.universite-paris-saclay.fr/supraconductivite/projet/smartphone/
Ressources
- https://www.co2meter.com/blogs/news/35432257-arduino-code-for-k-30-co2-sensor-works-for-s8-sensor-too
- https://www.instructables.com/Weather-and-Air-Quality-Monitor/
- https://www.airgradient.com/diy/
- https://esphome.io/components/sensor/senseair.html#senseair-co-2-sensor
voir aussi
- http://lafabrique.centralesupelec.fr/projetco2/
- http://lafabrique.centralesupelec.fr/webinairecapteursco2/
- https://ducotedelascience.org/acheter-un-detecteur-de-co2/
Compte twitter : https://twitter.com/nousaerons
ressources sur CO2 et santé
- https://www.anses.fr/fr/content/dioxyde-de-carbone-co2-dans-l%E2%80%99air-int%C3%A9rieur
- Valeurs Guides de qualité d’Air Intérieur (VGAI) : https://www.anses.fr/fr/content/valeurs-guides-de-qualit%C3%A9-d%E2%80%99air-int%C3%A9rieur-vgai
- https://www.kandu.fr/article/qualite-de-lair-interieur-impact-co2-sur-sante-efficacite/
- https://elpais.com/especiales/coronavirus-covid-19/a-room-a-bar-and-a-class-how-the-coronavirus-is-spread-through-the-air/
