Traçage/enregistrement de date/heure Arduino à l'aide de Millis () et de PfodApp : 11 étapes

2025 Auteur: John Day | [email protected]. Dernière modifié: 2025-01-23 14:46

Aucune programmation Arduino ou Android requise. Les modules RTC et GPS sont également pris en charge. Correction automatique des fuseaux horaires, de la dérive RTC et des secondes intercalaires manquantes du GPS

introduction

Ce didacticiel vous montre comment utiliser vos horodatages Arduino millis () pour tracer des données par rapport à la date et à l'heure sur votre mobile Android à l'aide de pfodApp.

Aucune programmation Arduino ou Android requise. pfodApp enregistre également suffisamment de données pour que vous puissiez ultérieurement reproduire les tracés date/heure dans une feuille de calcul.

AUCUN module RTC ou GPS n'est nécessaire, cependant si votre projet Arduino a un RTC (Real Time Clock) ou un module GPS, ils peuvent également être utilisés. Dans ces cas, les tracés pfodApp corrigeront automatiquement le fuseau horaire, la dérive RTC et les secondes intercalaires manquantes du GPS. Aucun code Arduino spécial n'est requis pour ces corrections. Comme toujours avec pfodApp, les données reçues sont enregistrées telles quelles, non corrigées, mais le fichier journal contient également suffisamment d'informations pour vous permettre d'appliquer vous-même ces corrections lorsque vous téléchargez les journaux sur votre ordinateur. Voir ci-dessous pour des exemples de ce post-traitement.

Une grande variété de formatage de l'axe X de l'heure et de la date est prise en charge, qui sont toutes entièrement contrôlées par de courtes chaînes de texte dans votre croquis Arduino. Aucune programmation Android n'est requise.

pfodApp se connectera via WiFi, Bluetooth Classic, BLE et SMS. Le pfodDesigner gratuit génère des croquis Arduino complets pour le traçage/enregistrement de date/heure afin de se connecter à une grande variété de cartes. Aucune programmation Arduino n'est requise.

Cette instructable utilisera un Adafruit Feather52 comme exemple de carte Arduino, qui se connecte via BLE.

Cette instructable couvre trois cas: - 1) Votre projet de microprocesseur n'a que des horodatages en millisecondes - millis () 2) Votre projet de microprocesseur a une horloge en temps réel (RTC) - pfodApp corrige automatiquement la dérive. 3) Votre projet de microprocesseur dispose d'un module GPS - pfodApp corrige automatiquement les secondes intercalaires au fur et à mesure qu'elles se produisent (actuellement 18 secondes en 2018).

Étape 1: Utilisation des horodatages Arduino millisecondes, Millis()

L'utilisation des millisecondes pour la date et l'heure comporte deux parties. L'une sert à tracer les données par rapport au temps écoulé ou à la date/l'heure et l'autre partie recrée la date et l'heure à partir des horodatages en millisecondes des données brutes enregistrées. pfodApp ne modifie pas les données brutes reçues du pfodDevice (le micro Arduino). Il enregistre juste exactement les octets reçus.

Utilisez d'abord le pfodDesigner gratuit pour générer un croquis Arduino pour votre micro qui enverra les millisecondes et les mesures de données à pfodApp pour le traçage/enregistrement. Cet exemple crée un menu pour la carte Adafruit Feather 52 BLE qui lit A0. Le didacticiel sur Adafruit Feather nRF52 LE - Contrôles personnalisés avec pfodApp passe en revue les étapes de pfodDesigner pour créer un menu pour le Feather nRF52 qui inclut un bouton Graphique, alors consultez-le pour plus de détails. Dans ce didacticiel, nous ajouterons simplement un bouton de graphique et utiliserons les nouvelles options de format de l'axe X pour tracer les lectures A0 en fonction du temps écoulé et de la date/heure.

La première partie de ce tutoriel passera par l'utilisation du pfodDesigner gratuit pour créer un exemple de graphique date/heure sur votre mobile Android. Lorsque vous êtes satisfait de l'affichage, vous pouvez générer le croquis Arduino qui le reproduira lorsque vous vous connecterez à pfodApp. Aucune programmation Android n'est requise et puisque pfodDesigner génère des croquis Arduino complets pour une grande variété de cartes Arduino, aucune programmation Arduino n'est requise non plus.

Étape 2: Ajout d'un graphique au menu

Téléchargez l'application pfodDesigner depuis Google Play, ouvrez-la et cliquez sur "Démarrer un nouveau menu"

Cliquez sur le bouton « Target Serial » puis sur le bouton « Bluetooth Low Energy » pour afficher la liste des 11 cartes BLE (faites défiler vers le bas pour voir les autres choix). Sélectionnez sur Adafruit Bluefruit Feather52.

Revenez au menu Édition et cliquez sur « Modifier l'invite » et définissez une invite appropriée pour ce menu, par ex. "Feather52" et texte en gras et taille +7. La couleur d'arrière-plan a été laissée comme "par défaut" Blanc

Revenez en arrière et cliquez sur « Ajouter un élément de menu », faites défiler vers le bas et sélectionnez « Bouton de graphique » qui ouvre l'écran d'édition du bouton de graphique. Vous pouvez modifier l'apparence du bouton ici. Dans ce cas, le texte du bouton a été remplacé par « Tracé date/heure de A0 » et les autres valeurs par défaut ont été laissées telles quelles.

Cela vous donne un bouton sur le menu qui ouvrira l'écran de carte.

Étape 3: Modification de la source et des étiquettes du tracé

Cliquez sur le bouton "Date/Time plot of A0" pour ouvrir l'écran Editing Plots, où vous pouvez accéder à l'étiquette du graphique, au format de l'axe X, à l'intervalle des données de tracé et (en faisant défiler vers le bas) aux paramètres de tracé eux-mêmes. Modifiez l'étiquette du graphique en quelque chose d'approprié, par ex. "A0 Volts".

Faites défiler vers le bas et pour les tracés 2 et 3, ouvrez Modifier le tracé et cliquez sur Masquer le tracé pour les supprimer de l'affichage du graphique.

Cliquez ensuite sur « Modifier le tracé 1 » et définissez une étiquette de tracé (par exemple A0), les unités de l'axe y (par exemple, les volts), affichez un maximum de 3,6 V et connectez-vous à la broche d'E/S A0.

Faites défiler vers le haut et cliquez sur « Aperçu du graphique » jusqu'aux 0 points de données d'échantillon les plus récents, à des intervalles de 1 seconde, tracés en fonction du temps écoulé en minutes: secondes.

Pour tous les tracés de temps écoulé, les unités zéro en tête ne sont pas affichées, donc dans ce tracé, seuls les temps > 1 min ont des minutes en tête.

Étape 4: Choix du format date/heure

Pour les tracés de temps écoulé, l'unité principale ne cesse d'augmenter au fur et à mesure que le temps passe. Pour voir un exemple de cela, retournez à l'écran "Modifier les tracés" et augmentez l'intervalle des données de tracé à 15 minutes (en bas de cet écran)

Cliquez ensuite sur Aperçu du graphique pour afficher les mêmes données d'échantillon, mais maintenant avec des intervalles de 15 minutes entre les échantillons. Comme vous pouvez le voir, la partie minutes de mm:ss ne cesse d'augmenter.

Maintenant, revenez en arrière et cliquez sur le bouton de l'axe X pour afficher une petite sélection de tous les formats de données/temps possibles sur l'axe X (faites défiler vers le bas pour en savoir plus)

Ci-dessus se trouve une sélection d'aperçus de graphiques utilisant différents formats d'axe X.

Les tracés date/heure affichés ici sont dans le fuseau horaire « local ». Il existe également des options de format pour tracer la date/l'heure en UTC. Pour un ensemble complet d'options de format de date/heure possibles, voir pfodSpecification.pfd.

Étape 5: Générer et tester l'esquisse Arduino

Une fois que vous êtes satisfait du format et de l'intervalle de données de votre graphique, vous pouvez accéder à l'écran « Menu d'édition_1 » et faire défiler vers le bas et « Générer le code » pour le tableau cible choisi. Voici un exemple de croquis pour l'Adafruit Feather52 utilisant des intervalles de données de 1 seconde et un format de temps écoulé mm:ss, pfodFeather52_timeplot.ino

Ci-dessus, un tracé de A0 du Feather52

Changer le format en Weekday hr:mins:sec (~E HH:mm:ss) et régénérer le code (pfodFeather52_dateplot.ino) donne un tracé comme le deuxième ci-dessus.

Vous pouvez modifier le format de l'axe X directement dans votre croquis Arduino, comme décrit ci-dessous.

Étape 6: Comment PfodApp trace-t-il la date/l'heure à partir de Millis () ?

Lorsque pfodApp se connecte, il se souvient de son heure "locale" et UTC et demande les horodatages des données de tracé actuelles de pfodDevice (la carte Arduino). En utilisant ces informations, pfodApp peut ensuite tracer des horodatages en millisecondes en tant que temps écoulé, c'est-à-dire en convertissant des millisecondes en heures minutes secondes, etc.

En regardant dans l'esquisse générée par Arduino (par exemple pfodFeather52_dateplot.ino), il y a trois petits morceaux de code qui gèrent le côté Arduino des tracés.

La section de code loop() qui gère la demande d'heure actuelle {@} de pfodApp

// gérer la demande {@} } else if('@'==cmd) { // pfodApp a demandé l'heure 'actuelle' plot_mSOffset = millis(); // capture les millis actuels en tant qu'horodatages de données brutes décalées parser.print(F("{@`0}")); // renvoie `0 en tant que millisecondes de données brutes 'actuelles'

Vous pouvez simplement renvoyer la valeur actuelle de millis(), mais millis() revient à 0 tous les 49,7 jours, ce qui ferait reculer le tracé. Ainsi, à la place, le code se souvient de la valeur actuelle en millisecondes () lorsque la requête {@} a été effectuée et renvoie {@`0}, c'est-à-dire un horodatage actuel en millisecondes égal à zéro. Ensuite, lors de l'envoi des points de données brutes, l'esquisse utilise

plot_1_var = analogRead(A0); // lecture de l'entrée sur le tracé // plot_2_var plot Masqué donc aucune donnée attribuée ici // plot_3_var plot Masqué donc aucune donnée affectée ici // envoie les données du tracé au format CSV parser.print(millis()-plot_mSOffset); // temps en millisecondes ….

de sorte que l'horodatage en millisecondes envoyé avec les données commence à 0 et augmente jusqu'à 49,7 jours. Si vous restez connecté en permanence pendant 49,7 jours, vous verrez l'intrigue reculer d'environ 50 jours. Se déconnecter et se reconnecter une fois tous les 49,7 jours évite cela.

La troisième partie du tracé date/heure est le message du tracé.

} else if('A'==cmd) { // l'utilisateur a appuyé sur -- 'Date/Time plot of A0' // dans le menu principal de Menu_1 // renvoie le msg de traçage. parser.print(F("{=A0 Volts~E HH:mm:ss|date|A0~~~Volts||}"));

Lorsque l'utilisateur appuie sur le bouton "Date/Time plot of A0", pfodApp envoie la commande {A} au pfodDevice et le pfodDevice répond avec le message de tracé, {=…{=A0 Volts~E HH:mm:ss|date |A0~~~Volts||}qui contient le format de l'axe X E HH:mm:ss

Les formats Java SimpleDateFormat sont acceptables ici. pfodApp Data Logging and Plotting et pfodSpecification.pdf ont plus de détails sur le message de tracé.

Étape 7: reproduire les tracés date/heure sur votre ordinateur

Par défaut, pfodApp enregistre toutes les données brutes entrantes dans un fichier journal sur votre mobile, sauf si vous avez désactivé cette journalisation dans l'écran d'édition de la connexion, voir pfodAppForAndroidGettingStarted.pdf

Lorsque vous modifiez pfodApp, un bref message s'affiche avec l'emplacement et le nom du fichier journal, par ex. /pfodAppRawData/pfod_bluefruit52.txt Ce fichier est au format CSV, délimité par des virgules, et après l'avoir transféré sur votre ordinateur (voir pfodAppForAndroidGettingStarted.pdf pour les options de transfert), vous pouvez l'ouvrir dans une feuille de calcul pour tracer les données.

Voici les premières lignes d'un fichier journal.

// pfodApp V3.0.360, heure locale, UTC, mS par jour, heure actuelle pfod bluefruit52 (mS), heure actuelle pfod bluefruit52, // connecté le, 2019/04/20 11:32:50.238, 2019/04/20 01:32:50.238, 86400000, 0, 366, 0,25,, 1366, 0,29,, 2366, 0,31,, 3366, 0,33,, 4366, 0,33,, Ci-dessus, vous pouvez voir l'heure "locale" et UTC à laquelle pfodApp s'est connecté au Feather52 et l'heure actuelle en mS que le Feather52 a signalée via la réponse {@..}. La dernière colonne est vide, car il n'y a pas de RTC ou de GPS et donc aucune heure actuelle en aaaa/MM/jj n'a été signalée par le Feather52.

Pour tracer les données par rapport au temps écoulé, soustrayez l'heure actuelle (mS) de l'horodatage en millisecondes, puis divisez par la valeur mS par jour. Voici la feuille de calcul avec la formule ajoutée et le résultat tracé. La feuille de calcul ci-dessous (pfod_bluefruit52.xls) est une feuille de calcul OpenOffice enregistrée au format Excel.

Dans OpenOffice, le tracé est un nuage de points et l'axe des x du tracé a été formaté en HH:MM:SS Remarque: les formats de date/heure de la feuille de calcul ne sont PAS les mêmes que les formats de tracé utilisés par pfodApp. Par exemple, dans pfodApp, MM correspond aux mois et mm aux minutes.

Pour tracer en fonction de la date et de l'heure, il vous suffit d'ajouter l'heure de connexion à l'heure de la feuille de calcul et de tracer à nouveau. (pfod_bluefruit52_date.xls)

Remarque: L'heure locale et l'UTC ont été importés sous forme de texte dans ma feuille de calcul, j'ai donc dû supprimer le début ' avant de les utiliser dans une formule.

Étape 8: Comment éviter la limite Millis() de 49,7 jours et pourquoi vous ne devriez pas

Comme mentionné ci-dessus dans Comment pfodApp trace-t-il la date/l'heure à partir de millis () ?, si vous restez connecté en continu pendant plus de 49,7 jours, les horodatages en millisecondes reviendront à zéro. Quelques lignes de code peuvent éviter cela mais ce n'est pas recommandé.

D'abord comment éviter l'enroulement. Ajoutez une autre variable int non signée pour garder une trace du nombre de fois où les horodatages se retournent et imprimez le résultat combiné en HEX.

uint_t mSwrapCount = 0;uint32_t lastTimeStamp = 0;

… plot_1_var = analogRead(A0); // lecture de l'entrée sur le tracé // plot_2_var plot Masqué donc aucune donnée attribuée ici // plot_3_var plot Masqué donc aucune donnée affectée ici // envoie les données du tracé au format CSV uint32_t timeStamp = millis()-plot_mSOffset; if (timeStamp < lastTimeStamp) { // timeStamp renvoyé à 0 mSwrapCount++; // ajoute un au compte } lastTimeStamp = timeStamp; parser.print("0x"); parser.print(msWrapCount, HEX); parser.print(timeStamp, HEX);// temps en millisecondes en HEX ….

Lors du retour de la réponse {@.., effacez également le mSwrapCount.

// gérer la demande {@} } else if('@'==cmd) { // pfodApp a demandé l'heure 'actuelle' plot_mSOffset = millis(); // capture les millis actuels en tant qu'horodatages de données brutes décalées mSwrapCount = 0; // efface le nombre d'enveloppes. parser.print(F("{@`0}")); // renvoie `0 en tant que millisecondes de données brutes 'actuelles'

Les horodatages donneront désormais la valeur « correcte » pour les 40,7 jours suivants * 65536 ~= 7308 ans.

pfodApp convertira automatiquement les horodatages hexadécimaux pour le traçage et les enregistrera exactement tels qu'ils ont été reçus, c'est-à-dire en hexadécimal. Dans la feuille de calcul (OpenOffice), vous utilisez cette formule pour convertir la chaîne hexadécimale, dans A2, en mS (où A1 est une cellule vide) =HEX2DEC(REPLACE(A2;1;2;A1))

Pourquoi tu ne veux pas faire ça

Comme indiqué ci-dessus, il est facile d'étendre les horodatages mS à plus de 50 jours. Cependant, vous ne voulez probablement pas le faire car ils deviennent de plus en plus imprécis. Un cristal typique de 16 MHz utilisé pour créer les résultats en millis () dans le micro a une précision d'environ 50 ppm (parties par million). Cela signifie qu'après 49,7 jours, l'horodatage en millisecondes peut être dépassé de 3 ½ minutes et cela ignore l'effet de la température sur la précision du cristal.

Sur de courtes périodes de connexion, cette imprécision n'est pas un problème car la réponse {@.. resynchronise l'horodatage en millisecondes avec la date/l'heure du mobile à chaque reconnexion. Cependant, si vous souhaitez rester connecté pendant de longues périodes (jours) et enregistrer en continu les données, vous devez utiliser quelque chose de plus précis que le millis() intégré, tel qu'un module RTC ou GPS.

Étape 9: Utilisation d'un RTC (Horloge en temps réel)

Il existe un certain nombre de modules RTC disponibles, l'un des plus précis est DS3231, par ex. Module DS3231 d'Adafruit. La précision indiquée est de +/- 2 ppm sur 0 à 40 °C. c'est-à-dire ~+/-5 sec/mois.

Si vous souhaitez tracer des données avec des horodatages date/heure, par ex. 2019/04/19 20:4:34, alors vous devez modifier la réponse {@ pour renvoyer la date/heure actuelle, par ex. {@`0~2019/4/19 3:33:5}. Voici quelques exemples de modifications de code à appliquer à l'esquisse générée par pfodDesigner pour l'utilisation d'un module RTC, en supposant que vous utilisez la bibliothèque RTClib et que vous avez ajouté le code pour initialiser le module RTC.

// gérer la demande {@} } else if('@'==cmd) { // pfodApp a demandé l'heure 'actuelle' plot_mSOffset = millis(); // capture les millisecondes actuelles en tant qu'horodatages de données brutes décalées parser.print(F("{@`0"}); // renvoie `0 en tant que millisecondes de données brutes 'actuelles' parser.print('~'); // démarre la chaîne de date/heure DateTime now = rtc.now() sendDateTime(&now); // envoie aaaa/M/d/ H:m:s à parser.print, passe l'adresse & as arg.parser.print('}'); // fin de {@ réponse par exemple {@`0~2019/4/19 3:33:5}….

// envoie la date et l'heure à l'analyseur printvoid sendDateTime(DateTime* dt) { parser.print(dt->year(), DEC); parser.print('/'); parser.print(dt->mois(), DEC); parser.print('/'); parser.print(dt->day(), DEC); parser.print(' '); parser.print(dt->heure(), DEC); parser.print(':'); parser.print(dt->minute(), DEC); parser.print(':'); parser.print(dt->second(), DEC); }

void sendData() { if (plotDataTimer.isFinished()) { plotDataTimer.repeat(); // redémarrer la minuterie de données de tracé, sans dérive // attribuer des valeurs aux variables de tracé à partir de vos variables de boucle ou lire les entrées ADC plot_1_var = analogRead(A0); // lecture de l'entrée du tracé // plot_2_var plot Masqué donc aucune donnée attribuée ici // plot_3_var plot Masqué donc aucune donnée affectée ici // envoie les données du tracé au format CSV DateTime now = rtc.now(); sendDateTime(&now); // envoyer aaaa/M/d/ H:m:s à parser.print, passer l'adresse & comme arg. parser.print(', '); parser.print(((float)(plot_1_var - plot_1_varMin)) * plot_1_scaling + plot_1_varDisplayMin); parser.print(', '); // Le tracé 2 est masqué. Aucune donnée envoyée. parser.print(', '); // Le tracé 3 est masqué. Aucune donnée envoyée. parser.println(); // fin de l'enregistrement de données CSV } }

La partie ~2019/4/19 3:33:5 de la réponse {@ permet à pfodApp de savoir ce que le pfodDevice pense être la date et l'heure actuelles. Votre croquis peut ensuite envoyer des données avec des horodatages yMd Hms et pfodApp les tracera soit sous forme de temps écoulé à partir de l'heure de connexion OU sous forme de date et d'heure, selon le format d'axe X que vous spécifiez.

Lors du tracé par rapport à la date et à l'heure, la routine de tracé pfodApp corrige toute « dérive » dans le RTC en comparant l'heure actuelle signalée par pfodDevice à l'heure actuelle du mobile. Cette correction gère également le réglage du RTC sur un fuseau horaire différent du fuseau horaire local de votre mobile. Les horodatages millis () continuent de fonctionner comme dans Utilisation des horodatages en millisecondes Arduino, étape 5 ci-dessus.

Voici un exemple de feuille de calcul des températures ambiantes sur une période de 8 jours, Office_Temp.xls Lorsque le fichier journal a été importé, la première colonne a été marquée comme AMJ pour convertir le texte en date/heure. Vous devez toujours supprimer le premier ' des entrées d'heure locale, UTC et Office Temp pour que la feuille de calcul les interprète comme des dates et des heures.

Pour obtenir le même tracé que pfodApp, vous devez calculer la « Date/Heure corrigée ». Dans ce cas, l'heure RTC est de 2 secondes derrière l'heure locale du mobile, donc à chaque horodatage RTC est ajouté (heure locale – heure actuelle Office Temp) pour obtenir l'heure locale réelle.

Pour les tracés de temps écoulé, créez une nouvelle colonne contenant le (horodatage date/heure - l'heure actuelle du bureau) et utilisez-le comme axe X dans le graphique (Office_TempElapsed.xls) En fait, dans ce cas, pfodApp produit des graphiques de temps écoulé plus agréables en jours h:min:sec.

Étape 10: Utilisation d'un module GPS

L'utilisation d'un module GPS est similaire à l'utilisation d'un module RTC, sauf que les modules GPS ont des millisecondes disponibles, les années commencent à 2000 et il manque les secondes intercalaires UTC (voir https://tycho.usno.navy.mil/leapsec.html) La date et l'heure GPS sont actuellement de 18 secondes en avance sur UTC, en janvier 2018.

La bibliothèque GPS Adafruit pour le GPS Adafruit Ultimate, contrairement à la RTClib, n'ajoute pas le décalage de 2000 ans aux années GPS, cela doit donc être ajouté lorsque vous envoyez l'horodatage de la date et de l'heure. De plus, bien que la bibliothèque GPS fournisse des millisecondes qui ont une très bonne précision à long terme, elles ne sont pas très précises. Les mises à jour de l'heure GPS n'ont lieu qu'une fois toutes les 100 mS, puis il y a un délai supplémentaire pour recevoir les données série à une vitesse lente de 9 600 bauds et un autre délai pour l'analyse. Tout cela ajoute à la précision de la milliseconde lors de l'horodatage des lectures de données.

Voici quelques exemples de modifications de code à appliquer à l'esquisse générée par pfodDesigner pour l'utilisation d'un module GPS, en supposant que vous utilisez la bibliothèque GPS d'Adafruit et que vous avez ajouté le code pour recevoir et analyser les messages dans un objet GPS.

// gérer la demande {@} } else if('@'==cmd) { // pfodApp a demandé l'heure 'actuelle' plot_mSOffset = millis(); // capture les millisecondes actuelles en tant qu'horodatages de données brutes décalées parser.print(F("{@`0"}); // renvoie `0 en tant que millisecondes de données brutes 'actuelles' parser.print('~'); // démarre la chaîne de date/heure sendDateTime(&GPS); // envoie aaaa/M/d/ H:m:s à parser.print, passe l'adresse & comme argument parser.print('}'); // fin de {@ réponse par exemple {@`0~2019/4/19 3:33:5}….

// envoie la date et l'heure à l'analyseur printvoid sendDateTime(Adafruit_GPS* gps) { parser.print(F("20"); // 20.. year parser.print(gps->year, DEC); parser.print('/ '); parser.print(gps->month, DEC); parser.print('/'); parser.print(gps->day, DEC); parser.print(' '); parser.print(gps- >heure, DEC); parser.print(':'); parser.print(gps->minute, DEC); parser.print(':'); parser.print(gps->second, DEC); // parser.print('.'); si vous envoyez des millisecondes // si vous voulez envoyer des mS, vous devez remplir la valeur gps-> millisecondes avec des zéros non significatifs // c'est-à-dire que 3 doit être rempli à 003 }

void sendData() { if (plotDataTimer.isFinished()) { plotDataTimer.repeat(); // redémarrer la minuterie de données de tracé, sans dérive // attribuer des valeurs aux variables de tracé à partir de vos variables de boucle ou lire les entrées ADC plot_1_var = analogRead(A0); // lecture de l'entrée sur le tracé // plot_2_var plot masqué donc aucune donnée affectée ici // plot_3_var plot masqué donc aucune donnée affectée ici // envoi des données du tracé au format CSV sendDateTime(&GPS); // envoyer aaaa/M/d/ H:m:s à parser.print, passer l'adresse & comme arg. parser.print(', '); parser.print(((float)(plot_1_var - plot_1_varMin)) * plot_1_scaling + plot_1_varDisplayMin); parser.print(', '); // Le tracé 2 est masqué. Aucune donnée envoyée. parser.print(', '); // Le tracé 3 est masqué. Aucune donnée envoyée. parser.println(); // fin de l'enregistrement de données CSV } }

Lors du traçage par rapport à la date et à l'heure, le pfodApp corrige automatiquement les secondes intercalaires. En janvier 2018, l'heure GPS est de 18 secondes en avance sur UTC. pfodApp corrige cela en comparant la date/heure renvoyée par le GPS lors de la connexion, via la réponse {@, avec la date et l'heure UTC du mobile. La création de tracés dans une feuille de calcul à partir du fichier journal pfodApp est la même que pour les modules RTC, ci-dessus. L'ajout de (heure locale - heure actuelle de Office Temp) aux horodatages GPS corrige les secondes intercalaires.

Les horodatages millis () continuent de fonctionner comme dans Utilisation des horodatages en millisecondes Arduino, étape 5 ci-dessus.

Étape 11: Conclusion

L'utilisation de pfodApp sur votre mobile Android vous permet de tracer des données en fonction de la date et de l'heure ou du temps écoulé, en utilisant uniquement la fonction millis () d'Arduino. En utilisant le fichier journal pfodApp, vous pouvez reproduire ces tracés date/heure dans une feuille de calcul. Si votre projet Arduino dispose d'un module RTC, vous pouvez enregistrer et tracer la date et les horodatages RTC, en corrigeant automatiquement la « dérive » RTC. Si votre projet Arduino dispose d'un module GPS, vous pouvez enregistrer et tracer ses horodatages très précis et pfodApp corrigera automatiquement les secondes intercalaires manquantes du GPS.

Dans tous les cas, les données brutes de votre projet Arduino sont enregistrées exactement telles qu'elles ont été reçues, non corrigées. Cependant, le fichier journal pfodApp inclut des données supplémentaires pour vous permettre de reproduire ces corrections dans une feuille de calcul à partir du fichier journal téléchargé.

Aucun codage Android n'est requis. Les formats de tracé sont tous spécifiés par de petites chaînes de texte dans votre croquis Arduino. Le pfodDesigner gratuit génère des croquis complets d'enregistrement de données Arduino et de traçage pour une grande variété de cartes Arduino se connectant via WiFi, Bluetooth classique, BLE et SMS