Comment créer un moniteur d'énergie et un enregistreur de données Arduino

À propos de ce projet

(Cet article est basé sur un article qui a été publié pour la première fois le 19 septembre 2017 sur Medium, et a été mis à jour et plus actuel ici, y compris les détails de la publication de la bibliothèque et des exemples sur GitHub).

Dans cet article, je vais vous montrer comment j'ai construit un moniteur d'énergie et un enregistreur de données Arduino qui m'aideraient à collecter facilement des données de courant et d'énergie pour différentes charges et à tracer ces informations à l'aide d'un programme comme Excel.

Certains d'entre vous savent peut-être que j'ai créé un nouveau tableau de bord de surveillance de l'énergie que j'appelle Dr. Wattson (qui est basé sur le #Microchip #MCP39F521, un circuit intégré de surveillance de l'alimentation) avec une bibliothèque #Arduino et une bibliothèque #Python ( pour des cartes comme #RaspberryPi et #BeagleBoneBlack) pour une intégration facile de données énergétiques de qualité dans votre prochain projet ! Si vous n'en avez pas entendu parler et que vous souhaitez plus d'informations, consultez https://upbeatlabs-wattson.launchrock.com/ pour plus d'informations. Il est également disponible sur Tindie.

Pour m'aider à étudier les caractéristiques énergétiques de différentes charges, je suis allé de l'avant et j'ai créé un moniteur d'énergie et un enregistreur de données Arduino, qui fait l'objet de cet article !

Il se compose d'un Arduino (bien sûr !) qui parle à la carte Dr. Wattson pour obtenir des données énergétiques, ainsi qu'une carte SD sur laquelle écrire les données. J'ai également ajouté un bouton pour basculer l'enregistrement des données, ainsi qu'un indicateur LED pour indiquer quand les données sont enregistrées. Le bouton ainsi que la LED ont rendu très facile le lancement de l'enregistrement des données lorsque la charge appropriée était branchée.

Pour faciliter la journalisation et l'analyse ultérieure, j'ai également mis en place un schéma de rotation des journaux, de sorte que chaque exécution sera enregistrée dans un fichier différent. La sortie est au format CSV, ce qui signifie qu'elle peut être facilement importée dans Excel (ou Numbers sur Mac ou autre équivalent), et les données tracées.

Configuration

J'ai placé la carte Dr. Wattson dans un boîtier en acrylique afin que les fils CA soient enfermés et que vous puissiez l'utiliser en toute sécurité ! Comme ceci :

J'ai ensuite un peu mis à jour le boîtier et il est maintenant disponible sur Tindie. Voilà à quoi ça ressemble maintenant. Un peu plus nettoyé avec une prise IEC supplémentaire et des connecteurs à fourche pour des connexions faciles.

J'ai préparé un manuel d'utilisation montrant comment le câblage doit être effectué, qui est maintenant disponible sur GitHub.

La sortie numérique provenant du Dr Wattson est complètement isolée du secteur, car la mesure de l'énergie est effectuée de manière isolée à l'aide de transformateurs de courant et de tension, de sorte que la sortie numérique est parfaitement sûre à manipuler.

Une fois dans le boîtier, tout ce que vous avez à faire est de brancher le câble dans une prise existante et de brancher n'importe quel appareil sur la prise du boîtier — le PCB est conçu pour des courants jusqu'à 12A, il est donc assez bien construit ! Il est calibré pour mesurer des courants jusqu'à 4A (je pourrais donc mesurer de très petits courants pour mesurer l'alimentation en veille  - la puce MCP39F521 sur laquelle elle est basée a un rapport dynamique de 4000:1, ce qui signifie qu'elle peut mesurer de 4A à 1mA)

Circuit

Voici le circuit que j'ai utilisé :

J'ai utilisé une carte SD similaire à celle d'Adafruit (je l'ai donc utilisée dans Fritzing, car c'était la partie la plus proche). La connexion est assez standard —CLK (Arduino Uno broche 13), MISO (Arduino Uno broche 12), MOSI (Arduino Uno broche 11) et CS (Chip select). CS est configurable, bien qu'il utilise par défaut la broche 10 pour le matériel CS — Je viens de l'utiliser.

Pour le bouton, j'utilise la bibliothèque Button de Jack Christensen, qui fournit un anti-rebond et une variété de choses utiles dans un package facile à utiliser. (https://github.com/JChristensen/Button). Le bouton utilise le pullup interne de l'Arduino, il n'a donc pas de pullups externes et utilise également une logique inversée (haut est désactivé, bas est activé)  —  tous ces éléments sont configurables en tant que paramètres du constructeur de bouton ! J'ai connecté le bouton à la broche 4, mais vous pouvez utiliser n'importe quelle broche disponible que vous aimez.

Je n'avais vraiment pas le temps et la patience de modéliser le Dr Wattson comme un nouveau rôle dans Fritzing, alors j'ai triché et j'ai utilisé les conseils de Z-HUT pour créer facilement une pièce personnalisée sans trop de bruit. Je recommande fortement de le regarder ! https://www.youtube.com/watch?v=dfxx8wF3Uhs — merci Z-HUT ! :-)

Le seul inconvénient est que je dois me contenter d'utiliser l'image de la maquette de la partie « IC générique » que j'ai modifiée pour représenter le Dr Wattson. C'est la vie !

Voici un aperçu des épingles du Dr Wattson (de gauche à droite) :

• SCL — pour la communication I2C, va à Arduino Uno A5
• SDA — pour la communication I2C, va à Arduino Uno A4
• ZCD — Zero Cross Detection — nous n'utilisons pas cette fonctionnalité dans cet exemple
• Événement — Indicateur d'événement — nous n'utilisons pas cette fonctionnalité dans cet exemple
• GND — Connectez-vous à Arduino GND
• VIN — Connectez-vous à Arduino 5V
• 3.3v — Connectez-vous à Arduino 3.3v
• GND — Connectez-vous à Arduino GND (vous n'avez besoin de connecter qu'une des broches GND)

Croquis

Bon, maintenant passons à la programmation proprement dite !

Permettez-moi de commencer par expliquer le croquis. Dans setup(), j'ai d'abord configuré les communications de la carte SD et les communications Dr.Wattson en appelant leurs méthodes begin() respectives.

// voir si la carte est présente et peut être initialisée :if (!SD.begin(CHIP_SELECT)) { Serial.println(F("Card failed, or not present")); // ne rien faire de plus :} wattson.begin(); // Passez l'adresse appropriée. La valeur par défaut est 0x74 

J'initialise également la broche LED en tant que OUTPUT.

// initialise la broche numérique en tant que sortie. pinMode(LED, SORTIE); 

Le bouton est déclaré globalement, je n'ai donc rien à faire dans la configuration du bouton.

#define BUTTON_PIN 4 //Connectez un bouton tactile (ou quelque chose de similaire) //de la broche Arduino 4 à la terre. #define PULLUP true //Pour simplifier les choses, nous utilisons la résistance de pullup interne de l'Arduino.#define INVERT true //Puisque la résistance de pullup maintiendra la broche haute à moins que le //commutateur ne soit fermé, il s'agit d'une logique négative, c'est-à-dire une valeur élevée état //signifie que le bouton n'est PAS enfoncé. (En supposant un interrupteur normalement ouvert.)#define DEBOUNCE_MS 20 //Un temps anti-rebond de 20 millisecondes fonctionne généralement bien pour les interrupteurs à bouton tactile.Bouton myBtn(BUTTON_PIN, PULLUP, INVERT, DEBOUNCE_MS); //Déclarer le bouton 

Mon enregistrement de données se fait dans des fichiers avec un nom comme DATAXX.CSV, où XX est un nombre (de 00 à 99, donc 100 fichiers). Je vérifie les noms de fichiers existants sur la carte SD et je choisis le dernier nom de fichier inutilisé — par exemple DATA15.CSV

char filename[] ="DATA00.CSV";setup() { ... // crée un nouveau fichier pour (uint8_t i =0; i <100; i++) { filename[4] =i /10 + « 0 » ; nom de fichier[5] =i%10 + '0' ; if (! SD.exists(nom de fichier)) { Serial.print(F("Le fichier de données est ")); Serial.println(nom de fichier); // n'ouvre un nouveau fichier que s'il n'existe pas break; // quitte la boucle ! le nom du fichier sera maintenant celui que nous désirons } }...} 

Dans la fonction loop(), une fois le bouton enfoncé, il bascule la variable readData, qui contrôle si je lis les données énergétiques.

void loop() { ... myBtn.read(); //Lire le bouton if (myBtn.wasReleased()) { //Si le bouton a été relâché, changer l'état de la LED readData =!readData; digitalWrite (LED, readData); } if (readData) { ... // lecture des données et sauvegarde sur carte SD, etc .......} 

Une fois readData basculé, je lis les données énergétiques du Dr Wattson et enregistre également l'heure :

UpbeatLabs_MCP39F521_FormattedData fData ; int readMCPretval =wattson.readMCP39F521(&data, NULL); non signé long currentMillis =millis();

et écrivez-le sur la carte SD :

 // si le fichier est disponible, écrivez-y :File dataFile =SD.open(filename, FILE_WRITE); if (dataFile) { dataFile.print(currentMillis); dataFile.print(","); dataFile.print(fData.currentRMS); dataFile.print(","); dataFile.print(fData.activePower); dataFile.print(","); dataFile.print(fData.reactivePower); dataFile.print(","); dataFile.println(fData.apparentPower); // imprime également sur le port série :dataFile.close(); } // si le fichier n'est pas ouvert, affiche une erreur :else { Serial.print(F("error opening ")); Serial.println(nom de fichier); }  

Si le bouton est à nouveau basculé, j'arrête la lecture/l'enregistrement des données.

Agir !

Une fois que j'ai compilé et téléchargé le croquis sur mon Arduino, obtenir des données énergétiques était assez facile.

J'ai branché la charge de mon choix — une lampe CFL. Je voulais voir la consommation de courant et d'énergie du point de vue d'un démarrage à froid, ainsi que d'un démarrage à chaud. J'ai branché la lampe, mais je ne l'ai pas allumée.

J'ai appuyé sur le bouton de mon circuit pour démarrer les mesures d'énergie — lors de l'enregistrement, la LED ROUGE me l'a dit ! J'ai ensuite allumé la lampe CFL et j'ai attendu jusqu'à ce que je pense avoir obtenu suffisamment de données —vous voyez, la CFL, au démarrage, consomme plus d'énergie que ce qui est annoncé (dans mon cas, une ampoule CFL de 14W), puis s'installe finalement à environ 14W. J'ai attendu que les lectures se soient calmées. J'ai ensuite appuyé sur le bouton pour désactiver la lecture.

Je pouvais maintenant éjecter ma carte SD et commencer à regarder les données !

PS — Pour enregistrer les données d'appareils supplémentaires, tout ce que vous avez à faire est de réinitialiser l'Arduino — il choisira le prochain DATAXX.CSV disponible dans lequel enregistrer les données, afin que vous puissiez facilement garder les données séparées.

Remarque : Au lieu d'utiliser le moniteur série Arduino, j'utilise la commande "screen" intégrée sur mon terminal Mac en tant que terminal série. Dans mon Sketch, j'imprime les données énergétiques sur Serial et j'émets également une commande "clearscreen" pour que la sortie ne bouge pas

Serial.write("\x1B" "c"); // Efface l'écran sur un terminal ordinaire wattson.printMCP39F521Data(&data); 

Cela ne fonctionne que sur un terminal ordinaire qui peut accepter des commandes de terminal comme ci-dessus, et ne fonctionne malheureusement pas sur le moniteur série Arduino. Cependant, une fois que vous essayez écran , vous ne reviendrez peut-être jamais sur Arduino Serial Monitor !

La commande ressemblera à ceci :

$ screen /dev/tty.usbmodem1411 9600 

où le premier paramètre est le "port série", et le second est la vitesse que vous avez configurée pour votre connexion série dans votre sketch Arduino.

Tracer les données dans Excel

Parce que le fichier au format CSV, le charger et le tracer dans Excel était assez facile. Je n'entrerai pas dans les détails ici, car il existe de nombreux tutoriels pour créer un graphique dans Excel. J'ai inséré une ligne contenant les en-têtes de colonnes

timestamp, currentRMS, activePower, reactivePower, apparentePower 

(note à moi-même — ce sera une future amélioration de mon Sketch — pour ajouter les en-têtes de colonne dans le CSV directement !)

J'ai choisi les points de données ci-dessus pour enregistrer et tracer. La consommation actuelle dans le temps est évidemment intéressante. Pourquoi activePower, réactivePower et apparentePower? En fonction des caractéristiques électriques de l'appareil, il peut s'agir d'une charge résistive, d'une charge réactive, ou quelque part entre les deux, et les trois paramètres de puissance nous renseignent ainsi sur ses caractéristiques globales, et aussi s'ils évoluent dans le temps. Ou alors je pense…

Jetons un coup d'œil à mes résultats pour une lampe CFL à partir d'un démarrage à froid :

Le courant culmine à environ 0,21 ampères avant de finalement s'établir à environ 0,18 ampères.

La puissance active culmine à environ 17 watts avant de finalement s'établir à environ 14,2 watts.

Une fois que cela s'est installé, j'ai éteint la LCF et j'ai attendu un peu avant de la rallumer (d'où la baisse du courant dans le graphique ci-dessus). Vous pouvez voir qu'une fois qu'une LFC s'est « réchauffée », elle s'habitue rapidement à sa consommation à l'état d'équilibre.

Conclusion

Il y a beaucoup de données et d'expériences intéressantes que vous pouvez faire avec les données énergétiques de vos appareils et appareils. J'étais ravi de commencer à mettre la main sur des données et à les partager avec vous !

Mon objectif avec le Dr Wattson est de permettre au Maker de disposer de données énergétiques de qualité et de les rendre plus accessibles, afin que vous puissiez les utiliser comme élément de base pour vos idées folles et folles.

Dr. Wattson est conçu pour être sûr à utiliser (en particulier avec le boîtier), est calibré (afin que vous puissiez obtenir des données énergétiques de qualité immédiatement), mais expose également des fonctionnalités plus complexes pour l'utilisateur sérieux

• routines d'étalonnage
• ZCD (détecteur de passage à zéro)
• Notification d'événement (événements de surintensité, de suralimentation, de baisse/surtension de tension)
• la possibilité de personnaliser la plage de lectures (en modifiant les résistances de charge et/ou CT et en les recalibrant à l'aide des routines d'étalonnage mentionnées ci-dessus),
• en utilisant plusieurs Dr. Wattsons avec un seul MCU (en modifiant l'adressage I2C configurable).

Si vous êtes intéressé par la surveillance de l'énergie et comme le Dr Wattson, veuillez vous inscrire sur (https://upbeatlabs-wattson.launchrock.com/) pour rester au courant des nouvelles et des mises à jour !

Bravo,

Sridhar

Voici l'ensemble du croquis, pour votre référence! Vous pouvez également le trouver ainsi que la bibliothèque Dr. Wattson, ainsi que de nombreux autres exemples dans le référentiel drwattson GitHub d'Upbeat Labs.

/************************************************ ************************************ Ceci est un exemple de croquis pour Upbeat Labs Dr. Wattson Energy Monitoring Breakout --> https://www.tindie.com/products/UpbeatLabs/dr-wattson-energy-monitoring-board-2/ Cet exemple montre comment obtenir des données énergétiques du Dr Wattson et les écrire sur une carte SD en les séparant par des virgules (CSV). Un bouton est utilisé pour basculer la collecte de données, vous pouvez donc enregistrer les données lorsque vous êtes prêt. Lorsque le bouton bascule la mesure, le croquis commence à interroger le module pour les données d'énergie et les imprime. Pour faciliter la visualisation des valeurs, utilisez un écran de type programme pour afficher la sortie série. La série écrit les caractères nécessaires pour effacer l'écran sur un terminal ordinaire, ce qui signifie que la sortie série restera en place et se mettra à jour au fil du temps. Allumez l'alimentation d'entrée pour voir la tension RMS, les valeurs de fréquence de ligne passent aux valeurs appropriées. Allumez la charge attachée à votre sortie pour voir le courant RMS, le facteur de puissance, les valeurs de puissance active, réactive et apparente changer. Toutes ces valeurs sont écrites sur la carte SD au format CSV, qui peut ensuite être utilisée avec un programme comme Excel pour afficher/tracer les données. Le nom du fichier est de la forme DATAnn.CSV. Au moment de la configuration, un nouveau nom de fichier est choisi qui n'existe pas déjà, les fichiers seront donc DATA00.CSV, DATA01.CSV, DATA02.CSV et ainsi de suite. La journalisation tourne vers de nouveaux fichiers jusqu'à DATA99.CSV. La communication se fait via I2C. 2 broches sont nécessaires pour l'interface. Il y a 4 possibilités d'adresses I2C sélectionnables par carte (sélectionnables via deux cavaliers à souder (qui sélectionnent chaque broche pour qu'elle soit haute ou basse). Sur cette base, il y a 4 adresses possibles :Adresse I2C SJ1 SJ2 0x74 LOW LOW 0x75 LOW HIGH 0x76 HIGH LOW 0x77 HIGH HIGH Dr. Wattson a deux sorties, ZCD ou Event, qui sont utilisées pour les notifications, et seront donc généralement connectées à une broche pouvant être interrompue de l'extérieur (comme la broche 2 ou la broche 3 sur Arduino Uno).Dans cet exemple, ZCD et Event ne sont pas Le bouton est connecté à la broche 4. * Carte SD connectée au bus SPI comme suit :** MOSI - broche 11 ** MISO - broche 12 ** CLK - broche 13 ** CS - broche 10 La LED est connectée à la broche 9 Écrit par Sridhar Rajagopal pour Upbeat Labs LLC. Licence BSD. Tout le texte ci-dessus doit être inclus dans toute redistribution*/#include #include "UpbeatLabs_MCP39F521.h"#include #include //https://github.com/JChristensen/Button#define BUTTON_PIN 4 //Connectez un bouton tactile (ou quelque chose de similaire) //depuis la broche Arduino 4 à la terre.#define PULLUP true //Pour simplifier les choses, nous utilisons la résistance de pullup interne de l'Arduino.#define INVERT true //Puisque la résistance de pullup gardera la broche haute à moins que le //commutateur ne soit fermé, c'est une logique négative, c'est-à-dire qu'un état haut // signifie que le bouton n'est PAS enfoncé. (En supposant un interrupteur normalement ouvert.)#define DEBOUNCE_MS 20 //Un temps anti-rebond de 20 millisecondes fonctionne généralement bien pour les interrupteurs à bouton tactile.Bouton myBtn(BUTTON_PIN, PULLUP, INVERT, DEBOUNCE_MS); //Déclarez le bouton#define LED 9 // Connectez une LED (via une résistance de 220ohm) de la broche 9 (anode) à GND (cathode). #define CHIP_SELECT 10UpbeatLabs_MCP39F521 wattson =UpbeatLabs_MCP39F521();bool readData =false;char filename[] ="DATA00.CSV";void setup() { Serial.begin(9600); //activer la communication série Serial.println(F("**Upbeat Labs Dr. Wattson Example Sketch**")); Serial.println(F("Esquisse d'exemple d'enregistrement de carte SD de données énergétiques du Dr Wattson d'Upbeat Labs")); Serial.println(F("************************************************ **************************")); // initialise la broche numérique en tant que sortie. pinMode (LED, SORTIE); pinMode(CHIP_SELECT, SORTIE); // voir si la carte est présente et peut être initialisée :if (!SD.begin(CHIP_SELECT)) { Serial.println(F("*** SD Card failed, or not present ***")); // ne rien faire de plus :} wattson.begin(); // Passez l'adresse appropriée. La valeur par défaut est 0x74 // crée un nouveau fichier pour (uint8_t i =0; i <100; i++) { filename[4] =i/10 + '0'; nom de fichier[5] =i%10 + '0' ; if (! SD.exists(nom de fichier)) { Serial.print(F("Le fichier de données est ")); Serial.println(nom de fichier); // n'ouvre un nouveau fichier que s'il n'existe pas break; // quitte la boucle ! le nom du fichier sera maintenant celui que nous désirons } } Serial.println(F("**initialisation terminée.**"));}void loop() { myBtn.read(); //Lire le bouton if (myBtn.wasReleased()) { //Si le bouton a été relâché, changer l'état de la LED readData =!readData; digitalWrite (LED, readData); } if (readData) { données UpbeatLabs_MCP39F521_Data ; UpbeatLabs_MCP39F521_FormattedData fData ; int readMCPretval =wattson.read(&data, NULL); non signé long currentMillis =millis(); if (readMCPretval ==UpbeatLabs_MCP39F521::SUCCESS) { // Imprimer le contenu Serial.write("\x1B" "c"); // Efface l'écran sur un terminal normal wattson.convertRawData(&data, &fData); printMCP39F521Data(&fData); // si le fichier est disponible, écrivez-y :File dataFile =SD.open(filename, FILE_WRITE); if (dataFile) { dataFile.print(currentMillis); dataFile.print(","); dataFile.print(fData.currentRMS); dataFile.print(","); dataFile.print(fData.activePower); dataFile.print(","); dataFile.print(fData.reactivePower); dataFile.print(","); dataFile.println(fData.apparentPower); // imprime également sur le port série :dataFile.close(); } // si le fichier n'est pas ouvert, affiche une erreur :else { Serial.print(F("error opening ")); Serial.println(nom de fichier); } } else { Serial.print(F("Erreur !")); Serial.println(readMCPretval); } }} void printMCP39F521Data(UpbeatLabs_MCP39F521_FormattedData *data){ Serial.print(F("Voltage =")); Serial.println(data->voltageRMS, 4); Serial.print(F("Current =")); Serial.println(data->currentRMS, 4); Serial.print(F("Fréquence de ligne =")); Serial.println(data->lineFrequency, 4); Serial.print("Tension d'entrée analogique ="); Serial.println(data->analogInputVoltage, 4); Serial.print(F("Facteur de puissance =")); Serial.println(data->powerFactor, 4); Serial.print(F("Active Power =")); Serial.println(data->activePower, 4); Serial.print(F("Puissance réactive =")); Serial.println(data->reactivePower, 4); Serial.print(F("Puissance apparente =")); Serial.println(data->apparentPower, 4);}

Code

• Extrait de code n° 1
• Extrait de code 3
• Extrait de code n° 4
• Extrait de code n°5
• Extrait de code n°7
• Extrait de code n°11

Extrait de code n°1Texte brut

// voir si la carte est présente et peut être initialisée :if (!SD.begin(CHIP_SELECT)) { Serial.println(F("Card failed, or not present")); // ne rien faire de plus :} wattson.begin(); // Passez l'adresse appropriée. La valeur par défaut est 0x74

Extrait de code n°3Texte brut

#define BUTTON_PIN 4 //Connectez un interrupteur à bouton tactile (ou quelque chose de similaire) //de la broche Arduino 4 à la terre. #define PULLUP true //Pour simplifier les choses, nous utilisons la résistance de pullup interne de l'Arduino.#define INVERT true //Puisque la résistance de pullup maintiendra la broche haute à moins que le //commutateur ne soit fermé, il s'agit d'une logique négative, c'est-à-dire une valeur élevée état //signifie que le bouton n'est PAS enfoncé. (En supposant un interrupteur normalement ouvert.)#define DEBOUNCE_MS 20 //Un temps anti-rebond de 20 millisecondes fonctionne généralement bien pour les interrupteurs à bouton tactile.Bouton myBtn(BUTTON_PIN, PULLUP, INVERT, DEBOUNCE_MS); //Déclarer le bouton

Extrait de code n°4Texte brut

char filename[] ="DATA00.CSV";setup() { ... // crée un nouveau fichier pour (uint8_t i =0; i <100; i++) { filename[4] =i/10 + « 0 » ; nom de fichier[5] =i%10 + '0' ; if (! SD.exists(nom de fichier)) { Serial.print(F("Le fichier de données est ")); Serial.println(nom de fichier); // n'ouvre un nouveau fichier que s'il n'existe pas break; // quitte la boucle ! le nom du fichier sera maintenant celui que nous désirons } }...}

Extrait de code n°5Texte brut

 monBtn.read(); //Lire le bouton if (myBtn.wasReleased()) { //Si le bouton a été relâché, changer l'état de la LED readData =!readData; digitalWrite (LED, readData); } if (readData) { ... // lit les données et enregistre sur la carte SD, etc ....

Extrait de code n°7Texte brut

 // si le fichier est disponible, écrivez-y :File dataFile =SD.open(filename, FILE_WRITE); if (dataFile) { dataFile.print(currentMillis); dataFile.print(","); dataFile.print(data.currentRMS); dataFile.print(","); dataFile.print(data.activePower); dataFile.print(","); dataFile.print(data.reactivePower); dataFile.print(","); dataFile.println(data.apparentPower); // imprime également sur le port série :dataFile.close(); } // si le fichier n'est pas ouvert, affiche une erreur :else { Serial.print(F("error opening ")); Serial.println(nom de fichier); } 

Extrait de code #11Texte brut