IA et lecture du détecteur de qualité de l’air

But

Le but est de démontrer le fonctionnement de base d’un réseau de neurones artificiels. Cette démonstration passe par la lecture de l’affichage du détecteur de qualité de l’air JSM-131 SE à partir d’un ordinateur et d’une caméra. Les données capturées sont enregistrées dans un fichier texte. Le formatage du fichier permettra d’importer ces données dans Excel pour analyse détaillée.

L’appareil ne fait que présenter les données sur un écran LCD. Une caméra capture ces données. Un programme, en Python, basé sur les réseaux de neurones artificiels interprète l’affichage des segments clairs, les transformant en chaîne de caractères compatibles à l’importation dans Excel.

La caméra se place à courte distance de détecteur, l’image ne doit pas être déformée. Les caméras web communes produisent une image en barillet (bombée), ce qui n’est pas adéquat. La caméra de marque ELP, modèle ELP-USBFHD01M-MFV, placée à 15 cm devant le détecteur, génère une image très peu déformée, de bonne qualité, facilement traitable. L’ouverture du diaphragme de la caméra s’opère manuellement, ce qui offre un ajustement de la luminosité parfaite et stable.

Équipements

Détecteur de qualité de l’air JSM-131 SE

VIVOSUN Moniteur de qualité de l’air – Testeur de CO2 – Détecteur de pollution intérieur – HCHO/TVOC/PM2.5/PM10 – Testeur avec données en temps réel et enregistrement de valeur moyenne pour la maison et le bureau : Amazon.ca: Commerce, Industrie et Science

Caméra

Mini webcam USB à objectif varifocal 2,8-12 mm haute définition USB avec caméra, mise au point manuelle, compatible avec la plupart des OS, mise au point réglable, webcam USB 2.0 haute vitesse : Amazon.ca: Électronique

Référence

Pour s’initier au traitement par réseau de neurones, je vous suggère de visionner le diaporama que j’ai produit sur ce sujet. Voir la partie « Simulation d’un réseau de neurones» :

https://espacerm.com/Rnia/rnia_cible.php?numero_image=001

Fonctionnement du réseau de neurones artificiels

Nous allons simuler, par programmation, un réseau de neurones précablé, fixe, configuré pour exécuter une tâche bien particulière. Ce réseau sera le plus simple possible, ayant une seule couche.

Programmation

Le traitement des images se fait à partir de la bibliothèque de fonctionnalités d’OpenCV.

Examinons, par étape, la programmation

# Défini le port de capture vidéo   
cap = cv2.VideoCapture(0)

# Lecture en boucle de l'image vidéo
while True:
    _, frame = cap.read()

L’image contenue dans «frame» est encodée en valeurs RGB (Rouge-Green-Blue) ou RVB (Rouge-Vert-Bleu)
Pour le traitement ultérieur, il faut que l’image soit encodée en valeurs HSV (Hue-Saturation-value) ou TSV (Teinte-Saturation-Valeur)

# Conversion de l'image RGB en HSV
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)

Création d’un masque qui servira à différentier les segments allumés du reste de l’image. Comme l’écran est en majorité de couleur bleue et que les segments allumés sont blancs, nous allons convertir ce qui est bleu (selon une certaine marge) en blanc, ce qui est blanc en noir.

    lower_blue = np.array([38, 112, 87])
    upper_blue = np.array([179, 255, 255])
    
    mask = cv2.inRange(hsv, lower_blue, upper_blue)

Affichage à l’écran de l’image originale et de l’image masque

    cv2.imshow("Frame", frame)
    cv2.imshow("Mask", mask)

Recherche de la position des segments

Maintenant, il s’agit de situer la position des segments dans l’image. Nous découpons la fenêtre en partie. Chaque partie correspond à une valeur de la mesure; HCHO, TVOC, PM2.5, PM10, Co2. Nous cherchons à quel pixel correspond le coin supérieur gauche du premier chiffre de la mesure. Par la méthode essais-erreurs, nous trouvons pour HCHO, le pixel y=69, x= 185 que nous pouvons aussi définir comme ligne 69, colonne 185.

    """""""""""""""""""""""""""""""""
    crop_img = source[y: y+h, x: x+w]
    """""""""""""""""""""""""""""""""
    HCHO = mask[69: 125:, 185: 480]
    cv2.imshow("HCHO", HCHO)

Par cet affichage, nous pouvons constater aussi que la caméra est bien alignée par rapport au détecteur. L’image ne penche pas, le haut des segments sont tous alignés sur l’horizontal.

Nous trouvons pour TVOC, le pixel y=127, x= 185.

TVOC = mask[127: 183:, 185: 480]
cv2.imshow("TVOC", TVOC)

Pour PM2.5, le pixel y=186, x= 185.

PM2_5 = mask[186: 242:, 185: 480]
cv2.imshow("PM2_5", PM2_5)

Pour PM10, le pixel y=246, x= 185.

    PM10 = mask[246: 302:, 185: 480]
    cv2.imshow("PM10", PM10)

Pour Co2, le pixel y=305, x= 185.

    CO2 = mask[305: 361:, 185: 480]
    cv2.imshow("CO2", CO2)

Recherche de la position des points décimaux

Il reste à trouver la position des points décimaux.

Pour le HCHO, le pixel 104, 220. Comme la valeur du HCHO sur cet appareil se situe entre 0 et 1.999, il n’y a qu’une position pour le point décimal.

    # HCHO maximum = 1.999
    HCHO_dot1 = mask[104: 109:, 220: 226]
    cv2.imshow("HCHO_dot1", HCHO_dot1)

Pour le TVOC, sa valeur se situe entre 0 et 12, il y a deux positions possibles pour le point décimal.

Première position du point décimal TVOC, pixel y=162, x=220 et pour la deuxième position, pixel y=162, x=272

    # TVOC maximum = 12
    TVOC_dot1 = mask[162: 168:, 220: 226]
    cv2.imshow("TVOC_dot1", TVOC_dot1)
    
    TVOC_dot2 = mask[162: 168:, 272: 278]
    cv2.imshow("TVOC_dot2", TVOC_dot2)

Il n’y a pas de point décimal pour les autres mesures; PM2.5, PM10, Co2.

Vue globale sur l’écran de l’ordinateur

Le mot «digit» sera employé dans la suite plutôt que «chiffre» pour référer à l’ensemble des 7 segments qui composent un chiffre. Cela a pour but de différentier entre chiffre la valeur 0,1,2,3,4,5,6,7,8,9 et chiffre en tant qu’unité, dizaine, centaine…

# Assignement mémoire pour 5 nombres de 4 «digits»
number=np.array([[1,2,3,4],[1,2,3,4],[1,2,3,4],[1,2,3,4],[1,2,3,4]])

    # Position en y (ligne) du premier pixel de chaque nombre
    posNumber=np.array([69,127,186,246,305])
    # Position en x (col) du premier pixel de chaque «digit»
    posDigit=np.array([185,239,289,340])

La position en x du premier pixel de chaque «digit» est déterminée encore par essais-erreurs.

La partie «réseau de neurones»

Deux boucles sont imbriquées pour retrouver chaque «digit» de chaque nombre qui correspond à une mesure.

    for m in range(0, 5): # 5 Nombres (position 0,1,2,3,4)
        line=posNumber[m]
        for j in range(0, 4): # 4 «digits» (position 0,1,2,3)
            col=posDigit[j]

Chaque «digit» est composé de 7 segments. Les segments sont allumés selon le chiffre à afficher.

Chaque segment est analysé selon l’état de 4 pixels qui en font parti. Les segments sont nommés a,b,c,d,e,f,g.

Le pixel nommé a1 vaut 1 s’il est noir ( == 0) sur le mask sinon il vaut -1

            # un pixel blanc sur le mask a comme valeur 255
            # un pixel noir sur le mask a comme valeur 0
            a1 = 1 if mask[line+1,col+9]== 0 else -1

Quatre pixels de chaque segment sont évalués pour éviter une fausse lecture si un pixel est brouillé par une poussière, un problème de caméra, de transmission, etc. C’est l’avantage du réseau de neurones, la lecture des chiffres est possible même si une partie de l’information est erronée.

    # Assignement mémoire pour 5 nombres de 4 «digits»
    number=np.array([[1,2,3,4],[1,2,3,4],[1,2,3,4],[1,2,3,4],[1,2,3,4]])
    
    # Position en y (ligne) du premier pixel de chaque nombre
    posNumber=np.array([69,127,186,246,305])
    # Position en x (col) du premier pixel de chaque «digit»
    posDigit=np.array([185,239,289,340])

    for m in range(0, 5): # 5 Nombres (position 0,1,2,3,4)
        line=posNumber[m]
        for j in range(0, 4): # 4 «digits» (position 0,1,2,3)
            col=posDigit[j]

            # un pixel blanc sur le mask a comme valeur 255
            # un pixel noir sur le mask a comme valeur 0
            a1 = 1 if mask[line+1,col+9]    == 0 else -1
            a2 = 1 if mask[line+1,col+10]   == 0 else -1
            a3 = 1 if mask[line+1,col+11]   == 0 else -1
            a4 = 1 if mask[line+1,col+12]   == 0 else -1

La position du pixel a1, du segment a, du premier nombre (HCH0), premier «digit» se calcul ainsi:

line = posNumber[0] égal 69 ; col=posDigit[0] égal 185

mask[line+1,col+9]

donc dans le mask[69+1,185+9], soit mask[ligne 70, colonne194]

            a1 = 1 if mask[line+1,col+9]== 0 else -1

Chaque segment est évalué

            a1 = 1 if mask[line+1,col+9]    == 0 else -1
            a2 = 1 if mask[line+1,col+10]   == 0 else -1
            a3 = 1 if mask[line+1,col+11]   == 0 else -1
            a4 = 1 if mask[line+1,col+12]   == 0 else -1

    
            b1 = 1 if mask[line+7,col+20]   == 0 else -1
            b2 = 1 if mask[line+8,col+20]   == 0 else -1
            b3 = 1 if mask[line+9,col+20]   == 0 else -1
            b4 = 1 if mask[line+10,col+20]  == 0 else -1

    
            c1 = 1 if mask[line+27,col+20]  == 0 else -1
            c2 = 1 if mask[line+28,col+20]  == 0 else -1
            c3 = 1 if mask[line+29,col+20]  == 0 else -1
            c4 = 1 if mask[line+30,col+20]  == 0 else -1   
           
    
            d1 = 1 if mask[line+37,col+9]   == 0 else -1
            d2 = 1 if mask[line+37,col+10]  == 0 else -1
            d3 = 1 if mask[line+37,col+11]  == 0 else -1
            d4 = 1 if mask[line+37,col+12]  == 0 else -1

    
            e1 = 1 if mask[line+27,col+0]   == 0 else -1
            e2 = 1 if mask[line+28,col+0]   == 0 else -1
            e3 = 1 if mask[line+29,col+0]   == 0 else -1
            e4 = 1 if mask[line+30,col+0]   == 0 else -1
           
    
            f1 = 1 if mask[line+7,col+0]    == 0 else -1
            f2 = 1 if mask[line+8,col+0]    == 0 else -1
            f3 = 1 if mask[line+9,col+0]    == 0 else -1
            f4 = 1 if mask[line+10,col+0]   == 0 else -1
           
    
            g1 = 1 if mask[line+18,col+9]   == 0 else -1
            g2 = 1 if mask[line+18,col+10]  == 0 else -1
            g3 = 1 if mask[line+18,col+11]  == 0 else -1
            g4 = 1 if mask[line+18,col+12]  == 0 else -1

La somme de la valeur trouvée pour chaque pixel pour chaque segment est calculée. Cette somme sera donc comprise entre 4 et -4.

            sa=a1+a2+a3+a4 # Segment a
            sb=b1+b2+b3+b4 # Segment b
            sc=c1+c2+c3+c4 # Segment c
            sd=d1+d2+d3+d4 # Segment d
            se=e1+e2+e3+e4 # Segment e
            sf=f1+f2+f3+f4 # Segment f
            sg=g1+g2+g3+g4 # Segment g

La valeur de sortie de chaque neurone est calculée. Exemple pour le neurone «1», il faut additionner la valeur des segments «b» et «c».

            # Assignement mémoire pour chaque chiffre à représenter
            r=np.array([0,1,2,3,4,5,6,7,8,9])
    
            r[0]=sa+sb+sc+sd+se+sf         # valeur de sortie du neurone «0»
            r[1]=sb+sc                     # valeur de sortie du neurone «1»
            r[2]=sa+sb+sg+se+sd            # valeur de sortie du neurone «2»
            r[3]=sa+sb+sg+sc+sd            # valeur de sortie du neurone «3»
            r[4]=sb+sc+sf+sg               # valeur de sortie du neurone «4»
            r[5]=sa+sf+sg+sc+sd            # valeur de sortie du neurone «5»
            r[6]=sa+sf+sg+se+sd+sc         # valeur de sortie du neurone «6»
            r[7]=sa+sb+sc                  # valeur de sortie du neurone «7»
            r[8]=sa+sb+sc+sd+se+sf+sg      # valeur de sortie du neurone «8»
            r[9]=sa+sb+sc+sd+sf+sg         # valeur de sortie du neurone «9»

Prochaine étape, il faut trouver la valeur maximum

 mx=max(r[0],r[1],r[2],r[3],r[4],r[5],r[6],r[7],r[8],r[9])

Il reste à trouver qui possède la valeur maximum

            for i in range(0, 10):
                if r[i] == mx: break
        
            number[m,j]=i

La valeur de i correspond au numéro du neurone qui a la valeur maximum de sortie. Le chiffre du «digit» traité correspond au numéro de neurone. Par exemple number[m,j]=i, si m=1, j=3 et i=7, number[1,3]=7, m=1 correspond à TVOC, j à la position du dernier «digit», celui complètement à droite, sa valeur affichée est 7.

Détection de la position du point décimal pour TVOC

        if m == 1:
 
            tvocD1a = 1 if mask[166,222]  == 0 else -1
            tvocD1b = 1 if mask[166,223]  == 0 else -1
            tvocD1c = 1 if mask[167,222]  == 0 else -1
            tvocD1d = 1 if mask[167,223]  == 0 else -1
            
            tvocD1 = tvocD1a+tvocD1b+tvocD1c+tvocD1d
            
            
            tvocD2a = 1 if mask[166,274]  == 0 else -1
            tvocD2b = 1 if mask[166,274]  == 0 else -1
            tvocD2c = 1 if mask[167,275]  == 0 else -1
            tvocD2d = 1 if mask[167,275]  == 0 else -1
            

            tvocD2 = tvocD2a+tvocD2b+tvocD2c+tvocD2d

Impression du nombre trouvé dans la console Python. Attente de 1 seconde (1000 millisecondes) avant de traiter une autre capture de la caméra. Sortir de la boucle si la touche «esc», key==27, est appuyée. Terminaison de la capture et fermeture des fenêtres.

        print(number[m])
        
    key = cv2.waitKey(1000)
    if key == 27:
        break
 
cap.release()
cv2.destroyAllWindows()
 

Programme complet

# -*- coding: utf-8 -*-
"""
 Créer le 2022-02-03

@auteur: Richard Morel

Air Quality Monitor

"""

import time

import cv2
import numpy as np


    
 # Défini le port de capture vidéo   
cap = cv2.VideoCapture(0)

# Lecture en boucle de l'image vidéo
while True:
    time.sleep(1)
    _, frame = cap.read()
    #print(frame.shape)

    # Conversion de l'image RGB en HSV
    hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
    
    lower_blue = np.array([38, 112, 87])
    upper_blue = np.array([179, 255, 255])
    
    mask = cv2.inRange(hsv, lower_blue, upper_blue)
    
    cv2.imshow("Frame", frame)
    cv2.imshow("Mask", mask)
    
    
    """""""""""""""""""""""""""""""""
    crop_img = source[y: y+h, x: x+w]
    """""""""""""""""""""""""""""""""
    colFin=480
        
    HCHO = mask[69: 125:, 185: colFin]
    cv2.imshow("HCHO", HCHO)

    TVOC = mask[127: 183:, 185: colFin]
    cv2.imshow("TVOC", TVOC)
    
    PM2_5 = mask[186: 242:, 185: colFin]
    cv2.imshow("PM2_5", PM2_5)
    
    PM10 = mask[246: 302:, 185: colFin]
    cv2.imshow("PM10", PM10)
    
    CO2 = mask[304: 360:, 185: colFin]
    cv2.imshow("CO2", CO2)
    
         
    # HCHO maximum = 1.999
    HCHO_dot1 = mask[104: 109:, 220: 226]
    cv2.imshow("HCHO_dot1", HCHO_dot1)
    
    # TVOC maximum = 12
    TVOC_dot1 = mask[162: 168:, 220: 226]
    cv2.imshow("TVOC_dot1", TVOC_dot1)
    
    TVOC_dot2 = mask[162: 168:, 272: 278]
    cv2.imshow("TVOC_dot2", TVOC_dot2)
    
    
   
    # Assignement mémoire pour 5 nombres de 4 «digits»
    number=np.array([[1,2,3,4],[1,2,3,4],[1,2,3,4],[1,2,3,4],[1,2,3,4]])
    
    # Position en y (ligne) du premier pixel de chaque nombre
    posNumber=np.array([69,127,186,246,305])
    # Position en x (col) du premier pixel de chaque «digit»
    posDigit=np.array([185,239,289,340])


    print('-')
    for m in range(0, 5): # 5 Nombres (position 0,1,2,3,4)
        line=posNumber[m]
        for j in range(0, 4): # 4 «digits» (position 0,1,2,3)
            col=posDigit[j]
            #print(col)
            #print(line)
            # un pixel blanc sur le mask a comme valeur 255
            # un pixel noir sur le mask a comme valeur 0
            a1 = 1 if mask[line+1,col+9]    == 0 else -1
            a2 = 1 if mask[line+1,col+10]   == 0 else -1
            a3 = 1 if mask[line+1,col+11]   == 0 else -1
            a4 = 1 if mask[line+1,col+12]   == 0 else -1

    
            b1 = 1 if mask[line+7,col+20]   == 0 else -1
            b2 = 1 if mask[line+8,col+20]   == 0 else -1
            b3 = 1 if mask[line+9,col+20]   == 0 else -1
            b4 = 1 if mask[line+10,col+20]  == 0 else -1

    
            c1 = 1 if mask[line+27,col+20]  == 0 else -1
            c2 = 1 if mask[line+28,col+20]  == 0 else -1
            c3 = 1 if mask[line+29,col+20]  == 0 else -1
            c4 = 1 if mask[line+30,col+20]  == 0 else -1   
           
    
            d1 = 1 if mask[line+37,col+9]   == 0 else -1
            d2 = 1 if mask[line+37,col+10]  == 0 else -1
            d3 = 1 if mask[line+37,col+11]  == 0 else -1
            d4 = 1 if mask[line+37,col+12]  == 0 else -1

    
            e1 = 1 if mask[line+27,col+0]   == 0 else -1
            e2 = 1 if mask[line+28,col+0]   == 0 else -1
            e3 = 1 if mask[line+29,col+0]   == 0 else -1
            e4 = 1 if mask[line+30,col+0]   == 0 else -1
           
    
            f1 = 1 if mask[line+7,col+0]    == 0 else -1
            f2 = 1 if mask[line+8,col+0]    == 0 else -1
            f3 = 1 if mask[line+9,col+0]    == 0 else -1
            f4 = 1 if mask[line+10,col+0]   == 0 else -1
           
    
            g1 = 1 if mask[line+18,col+9]   == 0 else -1
            g2 = 1 if mask[line+18,col+10]  == 0 else -1
            g3 = 1 if mask[line+18,col+11]  == 0 else -1
            g4 = 1 if mask[line+18,col+12]  == 0 else -1


    
    
            sa=a1+a2+a3+a4 # Segment a
            sb=b1+b2+b3+b4 # Segment b
            sc=c1+c2+c3+c4 # Segment c
            sd=d1+d2+d3+d4 # Segment d
            se=e1+e2+e3+e4 # Segment e
            sf=f1+f2+f3+f4 # Segment f
            sg=g1+g2+g3+g4 # Segment g
            
    
            # Assignement mémoire pour chaque «digit» à représenter
            r=np.array([0,1,2,3,4,5,6,7,8,9])
    
            r[0]=sa+sb+sc+sd+se+sf         # valeur de sortie du neurone «0»
            r[1]=sb+sc                     # valeur de sortie du neurone «1»
            r[2]=sa+sb+sg+se+sd            # valeur de sortie du neurone «2»
            r[3]=sa+sb+sg+sc+sd            # valeur de sortie du neurone «3»
            r[4]=sb+sc+sf+sg               # valeur de sortie du neurone «4»
            r[5]=sa+sf+sg+sc+sd            # valeur de sortie du neurone «5»
            r[6]=sa+sf+sg+se+sd+sc         # valeur de sortie du neurone «6»
            r[7]=sa+sb+sc                  # valeur de sortie du neurone «7»
            r[8]=sa+sb+sc+sd+se+sf+sg      # valeur de sortie du neurone «8»
            r[9]=sa+sb+sc+sd+sf+sg         # valeur de sortie du neurone «9»
    
            mx=max(r[0],r[1],r[2],r[3],r[4],r[5],r[6],r[7],r[8],r[9])
            #print (mx)
    
            for i in range(0, 10):
                if r[i] == mx: break
        
            number[m,j]=i
            
            #
            # HCHO_dot1 = mask[104: 109:, 220: 225]
            #

        if m == 1:
 
            tvocD1a = 1 if mask[166,222]  == 0 else -1
            tvocD1b = 1 if mask[166,223]  == 0 else -1
            tvocD1c = 1 if mask[167,222]  == 0 else -1
            tvocD1d = 1 if mask[167,223]  == 0 else -1
            
            tvocD1 = tvocD1a+tvocD1b+tvocD1c+tvocD1d
            
            
            tvocD2a = 1 if mask[166,274]  == 0 else -1
            tvocD2b = 1 if mask[166,274]  == 0 else -1
            tvocD2c = 1 if mask[167,275]  == 0 else -1
            tvocD2d = 1 if mask[167,275]  == 0 else -1
            

            tvocD2 = tvocD2a+tvocD2b+tvocD2c+tvocD2d
            
            
            print(tvocD1)
            print(tvocD2)

            
        print(number[m])
     

    key = cv2.waitKey(100)
    #(curseur dans une des imshow)
    if key == 27:
        break
  

cap.release()
cv2.destroyAllWindows()

Essais

Il faut vérifier que chaque «digit» est bien décodé pour les valeurs de 0 à 9. Le truc rapide est de faire « inhaler » un peu de Purel au détecteur ou souffler sur la flamme d’une chandelle près du détecteur. Les «digits» HCH0, TVOC passe par tous les chiffres éventuellement. C’est quand même un bon test pour le Co2 et les autres.

Programme incluant l’écriture des données sur disque

Comme l’image peut tout de même être déformée par la caméra (les «digits» n’ont pas exactement la même dimension et le même espacement), il est préférable de trouver la position exacte de chaque «digit» par essais-erreurs et de modifier le programme en conséquence.

La caméra a été bougée, donc les repères initiaux sont aussi modifiés. Les changements importants sont :

posDigit=np.array([[186,236,285,335],[186,234,284,334],[185,235,285,335],[185,235,283,332],[184,233,283,334]])

col=posDigit[m,j]

Vue globale du début de la boucle

    # Assignement mémoire pour 5 nombres de 4 «digits»
    number=np.array([[1,2,3,4],[1,2,3,4],[1,2,3,4],[1,2,3,4],[1,2,3,4]])
    
    # Position en y (ligne) du premier pixel de chaque nombre
    posNumber=np.array([70,125,181,238,294])
    # Position en x (col) du premier pixel de chaque «digit»
    posDigit=np.array([[186,236,285,335],
                       [186,234,284,334],
                       [185,235,285,335],
                       [185,235,283,332],
                       [184,233,283,334]])


    print('-')
    for m in range(0, 5): # 5 Nombres (position 0,1,2,3,4)
        line=posNumber[m]
        for j in range(0, 4): # 4 «digits» (position 0,1,2,3)
            col=posDigit[m,j]

Les données lues seront écrites dans un fichier «.txt». Le « ; » sert de délimiteur entre les données dans le fichier texte.

DATA_PATH = "C:/Documents/Programmation/Python/Travail/analyse d image/"
dataFileName = DATA_PATH + "dataDir_00/dataFile_00.txt" 
dataFile = open(dataFileName, 'a')  #mode «append», ajout

#Entête des colonnes
dataFile.write('Date;'+'Heure;'+'HCHO;'+'HCHO;'+'TVOC;'+'TVOC;'+'PM2.5;'
               +'PM2.5;'+'PM10;'+'PM10;'+'Co2;'+'Co2;'+'\r')

Nouveaux «masks» d’essais

Programme complet incluant l’écriture des données sur disque