Dans ce tutoriel, vous apprendrez à utiliser le capteur de poussière DSM501a avec un Arduino pour évaluer la qualité de l’air.
Le module capteur de poussière DSM501 combiné à des projets Arduino vous permet de surveiller la qualité de l’air. Grâce à sa capacité à détecter des particules aussi petites que 1 micron, ce module est idéal pour mesurer les concentrations de poussière domestique, pollen, acariens, germes et fumée de cigarette, connus pour être des causes de maladies respiratoires et d’allergies.
Commençons par les pièces nécessaires.
Pièces requises
En plus du DSM501, vous aurez besoin d’un Arduino ou d’un autre microcontrôleur avec une logique 5V. J’ai utilisé un Arduino Uno, mais toute autre carte Arduino avec une logique 5V fonctionnera tout aussi bien.

Capteur de poussière DSM501a

Arduino Uno

Jeu de fils Dupont

Plaque d’essai (breadboard)

Câble USB pour Arduino UNO
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
Principes de base du capteur de poussière DSM501
Le DSM501 est un module capteur pour mesurer les concentrations de particules. Le capteur peut détecter des particules aussi petites que 1µm et mesurer la quantité de particules en suspension dans une pièce jusqu’à une taille de 30m3. L’image ci-dessous montre l’arrière et l’avant du module capteur.

Fonctionnement
Le capteur fonctionne en utilisant un élément chauffant pour générer un flux d’air entrant. Les particules dans ce flux sont illuminées par une diode IR (LED) et la quantité de lumière réfléchie est mesurée par un capteur infrarouge (PT). Cette mesure est ensuite convertie en un signal de sortie PWM. L’image ci-dessous montre l’emplacement des composants et le principe de fonctionnement du capteur.

Voici une photo de l’intérieur du DSM501. Vous pouvez voir la résistance qui fait office d’élément chauffant en bas, le photodétecteur IR à droite, et la LED IR à gauche.

Installation
Le capteur doit être installé en position « verticale » comme illustré ci-dessous. Ce n’est que dans cette orientation que l’air chauffé s’écoulera vers le haut, passant devant la LED et l’élément détecteur. Veillez à éloigner le capteur de tout autre flux d’air artificiel (ventilateurs) et des sources d’humidité.

La lentille devant le détecteur IR (PT) est recouverte d’un polymère antistatique et anti-poussière. Mais elle doit tout de même être nettoyée tous les six mois en environnement de bureau et tous les trois mois en environnement industriel.
Le module dispose d’un potentiomètre VR pour ajuster la sensibilité, mais il est préréglé et ne doit pas être modifié.
Brochage
L’image suivante montre le brochage du DSM501. La broche de contrôle peut être ignorée pour l’instant. Vout1 et Vout2 sont les sorties PWM. Vout2 détecte les particules > 1µm et Vout1 détecte les particules > 2,5µm. VCC et GND sont les broches d’alimentation. Le module fonctionne en 5V.

Notez que le module DSM501 est généralement livré avec un connecteur et un câble préfabriqués dont le code couleur est erroné ! Ne vous laissez pas tromper. Le noir n’est PAS la masse et le rouge n’est PAS le VCC. Voir l’image ci-dessous et soyez vigilant.

Un mot rapide sur la broche de contrôle. Vous pouvez ajuster la sensibilité de taille des particules de Vout1 en ajoutant une résistance entre la broche de contrôle et la masse. Mais nous ne l’utiliserons pas et garderons les réglages par défaut : Vout2 (> 1µm) et Vout1 (> 2,5µm). Pour plus de détails, voir le datasheet. L’image ci-dessous montre comment le signal PWM des broches Vout varie selon la taille des particules détectées.

Spécifications
Vous trouverez ci-dessous les spécifications du DSM501. La partie la plus importante à noter est la tension d’alimentation de 5V et la consommation assez élevée de 90mA due à l’élément chauffant.
- Tension d’alimentation : DC5V±10%
- Consommation électrique : 90mA
- Plage de température de fonctionnement : -10~ +65℃
- Plage d’humidité de fonctionnement : 95% HR ou moins
- Conditions de stockage recommandées : -20~ +80℃
- Dimensions : L59 * H45 * P20 (mm)
- Taille minimale détectable des particules : environ 1µm
- Plage de concentration détectable : 0 ~ 1.4mg/m3
- Signal de sortie : PWM (modulation de largeur d’impulsion)
- Temps de stabilisation : 1 minute après mise sous tension
Pour plus de détails, consultez les fiches techniques. Il existe plusieurs versions légèrement différentes. J’ai listé les deux plus complètes ci-dessous
Connexion du DSM501 à l’Arduino
Connecter le DSM501 à un Arduino est simple. Commencez par relier GND à GND et VCC à 5V. Puis connectez Vout1 à la broche 7 de l’Arduino et Vout2 à la broche 8. Les broches GPIO spécifiques ne sont pas critiques, vous pouvez en choisir d’autres si vous préférez. La broche de contrôle du DSM501 reste non connectée (ouverte). Le schéma ci-dessous montre le câblage complet.

Une fois le câblage terminé, parlons de la manière dont nous allons mesurer les concentrations de particules avant d’écrire le code.
Mesure des concentrations de particules
Les broches Vout du DSM501 produisent un signal PWM dont la durée d’impulsion dépend de la quantité de particules détectées. Pour convertir ce signal en concentration de particules, il faut d’abord calculer le ratio dit low pulse ratio, comme décrit ci-dessous.

Le ratio d’impulsions basses est simplement le pourcentage du temps pendant lequel l’impulsion est basse durant la période de mesure t, typiquement entre 5 et 30 secondes. Par exemple, dans l’exemple ci-dessus, le ratio d’impulsions basses serait calculé comme
Low Pulse Ratio (%) = (t1 + t2 + t3) / t x 100
Concentration de particules en mg/m3
Une fois que nous avons le ratio d’impulsions basses, il faut consulter la concentration correspondante en mg/m3dans le graphique suivant. La courbe rouge décrit les caractéristiques typiques du capteur, tandis que les courbes bleue et rouge représentent les limites supérieure et inférieure.

Évidemment, nous voulons convertir le ratio d’impulsions basses en concentration de particules par une formule dans le code, sans consulter le graphique. Vous trouverez diverses formules dans différents articles, mais elles sont souvent légèrement inexactes. J’ai donc choisi quelques points de la courbe rouge ci-dessus pour reproduire le graphique et calculer un ajustement polynomial du second ordre. L’image ci-dessous montre les points et la courbe ajustée.

Les coefficients et la formule de l’ajustement polynomial sont les suivants :
c_mgm3 = 0.00258425*r**2 +0.0858521*r – 0.01345549
Avec cette formule, nous pouvons maintenant calculer la concentration de particules en mg/m3pour un ratio d’impulsions basses donné r.
Concentration de particules en pcs/283ml
De même, la fiche technique fournit une seconde courbe caractéristique pour mesurer la concentration en pcs/283ml.

Ce graphique montre une relation linéaire entre le ratio d’impulsions basses r et la concentration en pcs/283ml jusqu’à 12000 pcs/283ml, où le capteur sature. La partie linéaire peut être décrite par l’équation suivante :
c_pcs283ml = 625*r
Avec ces deux formules, nous avons tout ce qu’il faut pour calculer les concentrations de particules en mg/m3ou en pcs/283ml à partir d’un ratio d’impulsions basses mesuré r.
Code pour mesurer les concentrations de poussière avec le DSM501
Le code suivant montre comment mesurer les concentrations de particules en mg/m3et en pcs/283ml pour des particules de taille >1µm (PM1) ou >2,5µm (PM2.5). Jetez un œil rapide au code complet avant d’en détailler les parties.
const int pinPM25 = 7;
const int pinPM1 = 8;
const unsigned long sampleTime = 5000; // mSec -> 5..30 sec
float calc_low_ratio(float lowPulse) {
return lowPulse / sampleTime * 100.0; // low ratio in %
}
float calc_c_mgm3(float lowPulse) {
float r = calc_low_ratio(lowPulse);
float c_mgm3 = 0.00258425 * pow(r, 2) + 0.0858521 * r - 0.01345549;
return max(0, c_mgm3);
}
float calc_c_pcs283ml(float lowPulse) {
float r = calc_low_ratio(lowPulse);
float c_pcs283ml = 625 * r;
return min(c_pcs283ml, 12500);
}
void setup() {
Serial.begin(9600);
pinMode(pinPM25, INPUT);
pinMode(pinPM1, INPUT);
Serial.println("Warming up...");
// delay(60000); // 1 minute warm-up
}
void loop() {
static unsigned long t_start = millis();
static float lowPM = 0;
lowPM += pulseIn(pinPM25, LOW) / 1000.0; // >2.5µm (PM2.5)
//lowPM += pulseIn(pinPM1, LOW) / 1000.0; // >1µm (PM1)
if ((millis() - t_start) >= sampleTime) {
Serial.print("low_% PM : ");
Serial.println(calc_low_ratio(lowPM));
Serial.print("c_mgm3 PM : ");
Serial.println(calc_c_mgm3(lowPM));
Serial.print("c_pcs283ml PM: ");
Serial.println(calc_c_pcs283ml(lowPM));
Serial.println();
lowPM = 0;
t_start = millis();
}
}
Le code commence par définir des constantes pour les broches d’entrée du DSM501 et le temps d’échantillonnage. Le temps d’échantillonnage est la durée pendant laquelle le code effectue une mesure complète des concentrations de particules.
const int pinPM25 = 7; const int pinPM1 = 8; const unsigned long sampleTime = 5000; // mSec -> 5..30 sec
La fiche technique recommande une valeur entre 5 et 30 secondes. Un temps d’échantillonnage plus long donne des mesures plus stables mais moins fréquentes.
Fonctions utilitaires
Ensuite, nous définissons une fonction utilitaire pour calculer le ratio d’impulsions basses. Elle divise simplement le temps cumulé d’impulsions basses par le temps d’échantillonnage et multiplie par 100 pour obtenir un pourcentage.
float calc_low_ratio(float lowPulse) {
return lowPulse / sampleTime * 100.0; // low ratio in %
}
La calc_c_mgm3()fonction calcule la concentration de particules en mg/m3. Elle utilise la formule décrite ci-dessus. Nous limitons la concentration minimale à zéro en appelant max(0, c_mgm3), car une concentration négative n’a pas de sens.
float calc_c_mgm3(float lowPulse) {
float r = calc_low_ratio(lowPulse);
float c_mgm3 = 0.00258425 * pow(r, 2) + 0.0858521 * r - 0.01345549;
return max(0, c_mgm3);
}
Si vous regardez attentivement la courbe caractéristique du capteur, vous verrez que pour des ratios d’impulsions basses très faibles, la concentration calculée pourrait devenir négative.
De même, la calc_c_pcs283ml()fonction calcule la concentration en pcs/283ml mais limite la concentration maximale à 12500 pcs/283ml, où le capteur sature et la courbe caractéristique n’est plus linéaire.
float calc_c_pcs283ml(float lowPulse) {
float r = calc_low_ratio(lowPulse);
float c_pcs283ml = 625 * r;
return min(c_pcs283ml, 12500);
}
Fonction setup
La setup()fonction initialise la communication série et configure les modes des broches qui lisent les données du DSM501. La fiche technique indique que le capteur nécessite environ 1 minute de chauffe avant que les mesures deviennent stables. Vous pouvez activer le delaycorrespondant ici.
void setup() {
Serial.begin(9600);
pinMode(pinPM25, INPUT);
pinMode(pinPM1, INPUT);
Serial.println("Warming up...");
// delay(60000); // 1 minute
}
Fonction loop
Enfin, nous avons la loop()fonction. Elle utilise la pulseIn()fonction pour mesurer le temps bas de l’entrée P25 ou PM1. Il suffit de commenter l’entrée que vous ne souhaitez pas mesurer.
lowPM += pulseIn(pinPM25, LOW) / 1000.0; // >2.5µm (PM2.5) //lowPM += pulseIn(pinPM1, LOW) / 1000.0; // >1µm (PM1)
Notez que pulseIn retourne les durées en microsecondes, que nous convertissons en millisecondes en multipliant par 0,001.
Les temps bas sont accumulés jusqu’à la fin du temps d’échantillonnage. Ensuite, nous calculons les différentes concentrations de particules basées sur le ratio d’impulsions basses et les affichons.
if ((millis() - t_start) >= sampleTime) {
Serial.print("low_% PM : ");
Serial.println(calc_low_ratio(lowPM));
Serial.print("c_mgm3 PM : ");
Serial.println(calc_c_mgm3(lowPM));
Serial.print("c_pcs283ml PM: ");
Serial.println(calc_c_pcs283ml(lowPM));
Serial.println();
lowPM = 0;
t_start = millis();
}
À la fin du temps d’échantillonnage, nous remettons la concentration accumulée lowPMà 0 et réinitialisons aussi le temps d’échantillonnage pour commencer la période suivante.
Dans la section suivante, nous améliorerons ce système et construirons un simple système d’alerte de qualité de l’air.
Système d’alerte de qualité de l’air avec DSM501
Une exposition prolongée à de petites particules en suspension peut causer des problèmes de santé. Une méthode courante pour mesurer la qualité de l’air ambiant est de compter la concentration de particules fines (PM) de diamètre inférieur à 2,5µm. Le risque sanitaire lié aux PM2.5 est qu’elles peuvent pénétrer profondément dans les voies respiratoires, atteindre les poumons et entrer dans la circulation sanguine.
Il existe différentes échelles pour classer le risque sanitaire selon les concentrations de PM2.5. Le tableau suivant des catégories de qualité de l’air provient du Victorian Government in Australia.

Vous pouvez voir que les catégories vont de Bonà Extrêmement mauvaiset dépendent de la concentration moyenne de PM2.5 sur une ou 24 heures. Notez que ces catégories sont basées sur des concentrations de PM2.5 mesurées en µg/m3et non en mg/m3, unité que nous avons utilisée précédemment. Pour plus d’informations détaillées sur ces niveaux et leur impact potentiel sur la santé, consultez Air quality categories and general health advice.
Nous allons construire un système d’alerte de qualité de l’air simplifié en utilisant seulement les trois premiers niveaux (Bon à Mauvais). Selon la concentration mesurée de PM2.5, le système allumera une LED verte (Bon), jaune (Moyen) ou rouge (Mauvais ou pire).
Câblage pour le système d’alerte de qualité de l’air
Nous pouvons utiliser le même circuit qu’avant, sans modifier le câblage du DSM501, et simplement ajouter les trois LED avec leurs résistances de limitation de courant. La LED verte sera connectée à la broche 4, la jaune à la broche 3 et la rouge à la broche 2. L’image ci-dessous montre le câblage complet.

Code pour le système d’alerte de qualité de l’air
Le code ci-dessous est très similaire à celui vu précédemment. Les principales différences sont que nous commandons maintenant trois LED, et que nous mesurons les concentrations de PM2.5 en µg/m3.
const int pinPM25 = 7;
const int pinPM1 = 8;
const int pinGreen = 4;
const int pinYellow = 3;
const int pinRed = 2;
const unsigned long sampleTime = 30000; // 30 sec
float calc_low_ratio(float lowPulse) {
return lowPulse / sampleTime * 100.0; // low ratio in %
}
float calc_c_ugm3(float lowPulse) {
float r = calc_low_ratio(lowPulse);
float c_mgm3 = 0.00258425 * pow(r, 2) + 0.0858521 * r - 0.01345549;
return max(0, c_mgm3) * 1000;
}
void setup() {
pinMode(pinPM25, INPUT);
pinMode(pinPM1, INPUT);
pinMode(pinGreen, OUTPUT);
pinMode(pinYellow, OUTPUT);
pinMode(pinRed, OUTPUT);
// delay(60000); // 1 minute
}
void loop() {
static unsigned long t_start = millis();
static float lowPM25 = 0;
lowPM25 += pulseIn(pinPM25, LOW) / 1000.0;
if ((millis() - t_start) >= sampleTime) {
float c_ugm3 = calc_c_ugm3(lowPM25);
digitalWrite(pinGreen, c_ugm3 <= 25 ? HIGH : LOW);
digitalWrite(pinYellow, c_ugm3 > 25 && c_ugm3 <= 50 ? HIGH : LOW);
digitalWrite(pinRed, c_ugm3 > 50 ? HIGH : LOW);
lowPM25 = 0;
t_start = millis();
}
}
D’abord, nous définissons les constantes pour les broches du DSM501, les broches des LED et le temps d’échantillonnage.
Notez que nous utilisons un temps d’échantillonnage de 30 secondes. Vous pourriez le changer à une heure, comme dans la définition des catégories de qualité de l’air, mais cela ne vous donnerait qu’une mesure par heure. La meilleure option serait d’utiliser une fenêtre glissante, mais pour garder le code simple, je ne l’ai pas implémentée.
La calc_low_ratio()fonction est la même que précédemment et la nouvelle calc_c_ugm3()est essentiellement la même que l’ancienne calc_c_mgm3()fonction. Nous multiplions simplement par 1000 pour convertir de mg/m3en µg/m3.
Dans la fonction setup, nous configurons les modes des broches et dans la fonction loop, nous mesurons la concentration de PM2.5 et allumons ou éteignons l’une des trois LED selon le niveau.
... digitalWrite(pinGreen, c_ugm3 <= 25 ? HIGH : LOW); digitalWrite(pinYellow, c_ugm3 > 25 && c_ugm3 <= 50 ? HIGH : LOW); digitalWrite(pinRed, c_ugm3 > 50 ? HIGH : LOW); ...
Pour une concentration de PM2.5 < 25 µg/m3(Bon), nous allumons la LED verte. Pour une concentration entre 25 µg/m3et 50 µg/m3(Moyen), nous allumons la LED jaune et au-dessus de 50 µg/m3(Mauvais), nous allumons la LED rouge.
La courte vidéo suivante montre le système en action. Vous pouvez voir la LED rouge s’allumer lorsque le capteur est exposé à la poussière produite par un plumeau en mouvement.

Et voilà votre propre petit système d’alerte de qualité de l’air !
Conclusions
Le DSM501 est un capteur bon marché et facile à utiliser pour mesurer les concentrations de particules PM1 et PM2.5. Associé à un Arduino, il permet de construire un système simple d’alerte de qualité de l’air.
L’inconvénient du capteur est que la documentation est un peu limitée. J’ai dû déduire les formules pour mesurer les concentrations de particules à partir des courbes caractéristiques du capteur dans la fiche technique, ce qui est un peu imprécis. Vous constaterez que différents articles utilisent des formules légèrement différentes.
Je ne sais pas à quel point le DSM501 est précis, et sans source de particules connue, il est difficile de calibrer le capteur. Cependant, pour des estimations approximatives de la qualité de l’air, il devrait suffire.
Enfin, si vous souhaitez un capteur capable de détecter des particules plus petites, consommant moins d’énergie et compatible avec un ESP32, jetez un œil au GP2Y1010AU0F Dust Sensor.
Liens
Voici quelques liens que j’ai trouvés utiles pour rechercher des informations sur la qualité de l’air, les tailles de particules et le pollen.
- PM2.5
- Particulate matter (PM10 and PM2.5)
- Particle size matters
- Air pollution – How to convert between mg/m3, µg/m3 and ppm, ppb
- A systematic literature review on indoor PM2.5 concentrations and personal exposure in urban residential buildings
- Recent Insights into Particulate Matter (PM2.5)-Mediated Toxicity in Humans: An Overview
- Characterization of sub-pollen particles in size-resolved atmospheric aerosol using chemical tracers
FAQ
Quels sont les niveaux de densité de poussière sains et malsains mesurés en µg/m3?
Les niveaux sains de densité de poussière sont généralement inférieurs à 50 µg/m3, tandis que les niveaux malsains sont supérieurs à 150 µg/m3.
Quelle est la relation entre la densité de poussière mesurée en µg/m3et les particules en suspension PM, notamment PM2.5 et PM10 ?
La densité de poussière mesurée en µg/m3est directement liée aux particules en suspension (PM), y compris PM2.5 et PM10. PM2.5 désigne les particules de diamètre 2,5 µm ou moins, tandis que PM10 désigne les particules de diamètre 10 µm ou moins. Une densité de poussière plus élevée indique des niveaux plus importants de PM2.5 et PM10 dans l’air.

Pourquoi la pollution PM2.5 est-elle mauvaise pour la santé ?
Parmi toutes les mesures de pollution de l’air, la pollution PM2.5 représente la plus grande menace pour la santé. En raison de leur petite taille, les PM2.5 peuvent rester en suspension dans l’air pendant de longues périodes et être absorbées profondément dans le sang lors de l’inhalation.
Quelles sont les principales sources de pollution PM2.5 ?
Les sources courantes de pollution PM2.5 sont les moteurs et la combustion, les processus industriels, les poêles, cheminées et chauffages au bois domestiques, la fumée des feux d’artifice et des incendies de forêt, le tabagisme, ainsi que les particules de poussière et de pollen.
Un capteur PM2.5 ou PM10 peut-il mesurer le pollen ?
La plupart des particules de pollen sont plus grosses que les particules PM2.5 et PM10 et seraient ignorées par un capteur PM2.5 ou PM10. Cependant, bien que les particules de pollen soient généralement supérieures à 10 µm, elles peuvent se fragmenter en particules plus petites dans la gamme PM2.5, qui peuvent être mesurées.

