Trazado / registro de fecha / hora de Arduino usando Millis () y PfodApp: 11 pasos

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:42

No se requiere programación Arduino o Android. También se admiten módulos RTC y GPS. Corrección automática para zonas horarias, deriva de RTC y segundos intercalares faltantes de GPS

Introducción

Este tutorial le muestra cómo usar las marcas de tiempo de Arduino millis () para trazar datos contra la fecha y la hora en su dispositivo móvil Android usando pfodApp.

No se requiere programación Arduino o Android. pfodApp también registra datos suficientes para que luego pueda reproducir los gráficos de fecha / hora en una hoja de cálculo.

NO se necesita ningún módulo RTC o GPS, sin embargo, si su proyecto Arduino tiene un RTC (reloj en tiempo real) o un módulo GPS, también se pueden utilizar. En esos casos, los gráficos de pfodApp corregirán automáticamente la zona horaria, la deriva de RTC y los segundos intercalares faltantes del GPS. No se requiere ningún código Arduino especial para estas correcciones. Como siempre con pfodApp, los datos recibidos se registran exactamente como están, sin corregir; sin embargo, el archivo de registro también contiene información suficiente para permitirle aplicar estas correcciones usted mismo cuando descargue los registros a su computadora. Consulte a continuación para ver ejemplos de este posprocesamiento.

Se admite una amplia variedad de formato de eje X de fecha y hora, todos los cuales están completamente controlados por cadenas de texto cortas en su boceto de Arduino. No se requiere programación de Android.

pfodApp se conectará a través de WiFi, Bluetooth Classic, BLE y SMS. El pfodDesigner gratuito genera bocetos completos de Arduino para el trazado / registro de fecha / hora para conectarse a una amplia variedad de placas. No se requiere programación Arduino.

Este instructable usará un Adafruit Feather52 como la placa Arduino de ejemplo, que se conecta a través de BLE.

Este instructivo cubre tres casos: - 1) Su proyecto de microprocesador solo tiene marcas de tiempo de milisegundos - milis () 2) Su proyecto de microprocesador tiene un reloj en tiempo real (RTC) - pfodApp corrige automáticamente la desviación. 3) Su proyecto de microprocesador tiene un módulo GPS: pfodApp corrige automáticamente los segundos intercalares a medida que ocurren (actualmente 18 segundos en 2018).

Paso 1: Uso de marcas de tiempo de milisegundos de Arduino, Millis ()

Hay dos partes para usar milisegundos para la fecha y la hora. Una es para trazar los datos contra el tiempo transcurrido o la fecha / hora y la otra parte es volver a crear la fecha y la hora a partir de las marcas de tiempo de milisegundos de datos sin procesar registrados. pfodApp no modifica los datos brutos recibidos del pfodDevice (el micro Arduino). Simplemente registra exactamente los bytes recibidos.

Primero use el pfodDesigner gratuito para generar un boceto de Arduino para su micro que enviará los milisegundos y las mediciones de datos a pfodApp para trazar / registrar. Este ejemplo crea un menú para el tablero Adafruit Feather 52 BLE que dice A0. El tutorial sobre Adafruit Feather nRF52 LE - Controles personalizados con pfodApp sigue los pasos de pfodDesigner para crear un menú para el Feather nRF52 que incluye un botón Gráfico, así que échale un vistazo para obtener más detalles. En este tutorial, agregaremos solo un botón de gráfico y usaremos las nuevas opciones de formato del eje X para trazar las lecturas A0 contra el tiempo transcurrido y la fecha / hora.

La primera parte de este tutorial pasará por el uso del pfodDesigner gratuito para crear un gráfico de fecha / hora de muestra en su dispositivo móvil Android. Cuando esté satisfecho con la pantalla, puede generar el boceto de Arduino que lo reproducirá cuando se conecte con pfodApp. No se requiere programación de Android y, dado que pfodDesigner genera bocetos completos de Arduino para una amplia variedad de placas Arduino, tampoco se requiere programación de Arduino.

Paso 2: agregar un gráfico al menú

Descargue la aplicación pfodDesigner de Google Play, ábrala y haga clic en "Iniciar nuevo menú"

Haga clic en "Target Serial" y luego en el botón "Bluetooth Low Energy" para mostrar la lista de unas 11 placas BLE (desplácese hacia abajo para ver las otras opciones). Seleccione Adafruit Bluefruit Feather52.

Vuelva al menú Edición y haga clic en "Editar mensaje" y establezca un mensaje adecuado para este menú, p. Ej. "Feather52" y texto en negrita y tamaño +7. El color de fondo se dejó como el blanco 'predeterminado'

Regrese y haga clic en "Agregar elemento de menú", desplácese hacia abajo y seleccione "Botón de gráfico" que abre la pantalla de edición del botón de gráfico. Puede realizar cualquier cambio en la apariencia del botón aquí. En este caso, el texto del botón se cambió a "Gráfico de fecha / hora de A0" y los demás valores predeterminados se dejaron como están.

Esto le da un botón en el menú que abrirá la pantalla del gráfico.

Paso 3: editar la fuente de la gráfica y las etiquetas

Haga clic en el botón "Gráfico de fecha / hora de A0" para abrir la pantalla Editar gráficos, donde puede acceder a la etiqueta del gráfico, el formato del eje X, el intervalo de datos del gráfico y (desplazándose hacia abajo) la configuración del gráfico. Edite la etiqueta del gráfico a algo adecuado, p. Ej. “A0 Voltios”.

Desplácese hacia abajo y para los gráficos 2 y 3, abra Editar gráfico y haga clic en Ocultar gráfico para eliminarlos de la pantalla del gráfico.

A continuación, haga clic en "Editar gráfico 1" y establezca una etiqueta de gráfico (por ejemplo, A0), unidades de eje y (por ejemplo, voltios), muestre un máximo de 3,6 V y conéctelo al pin de E / S A0.

Desplácese hacia arriba y haga clic en "Vista previa del gráfico" hasta los 0 puntos de datos de muestra más recientes, a intervalos de 1 segundo, representados frente al tiempo transcurrido en minutos: segundos.

Para todos los gráficos de tiempo transcurrido, las unidades de cero iniciales no se muestran, por lo que en este gráfico solo se muestran los minutos iniciales en aquellos tiempos> 1 min.

Paso 4: elegir el formato de fecha / hora

Para los gráficos de tiempo transcurrido, la unidad principal sigue aumentando a medida que pasa el tiempo. Para ver un ejemplo de esto, vuelva a la pantalla "Editar gráficos" y aumente el intervalo de datos del gráfico a 15 minutos (parte inferior de esta pantalla).

Luego haga clic en Vista previa del gráfico para mostrar los mismos datos de muestra, pero ahora con intervalos de 15 minutos entre muestras. Como puede ver, la parte de minutos de mm: ss sigue aumentando.

Ahora regrese y haga clic en el botón del eje X para mostrar una pequeña selección de todos los posibles formatos de datos / tiempo del eje X (desplácese hacia abajo para ver más)

Arriba hay una selección de vistas previas de gráficos que utilizan diferentes formatos del eje X.

Los gráficos de fecha / hora que se muestran aquí están en la zona horaria 'local'. También hay opciones de formato para trazar la fecha / hora en UTC. Para obtener un conjunto completo de posibles opciones de formato de fecha / hora, consulte pfodSpecification.pfd.

Paso 5: Genere y pruebe el boceto de Arduino

Una vez que esté satisfecho con el formato de su gráfico y el intervalo de datos, puede ir a la pantalla "Menú de edición_1" y desplazarse hacia abajo y "Generar código" para el tablero de destino elegido. Aquí está un boceto de muestra para Adafruit Feather52 usando intervalos de datos de 1 segundo y un formato de tiempo transcurrido mm: ss, pfodFeather52_timeplot.ino

Arriba hay un gráfico de A0 del Feather52

Cambiar el formato a Weekday hr: mins: sec (~ E HH: mm: ss) y volver a generar el código (pfodFeather52_dateplot.ino) da un gráfico como el segundo anterior.

Puede editar el formato del eje X directamente en su boceto de Arduino, como se describe a continuación.

Paso 6: ¿Cómo traza PfodApp la fecha / hora desde Millis ()?

Cuando pfodApp se conecta, recuerda su hora 'local' y UTC y solicita las marcas de tiempo de los datos de trazado actuales de pfodDevice (la placa Arduino). Con esta información, pfodApp puede trazar marcas de tiempo de milisegundos como tiempo transcurrido, es decir, convertir milisegundos a horas, minutos, seg, etc., o trazar la fecha y la hora que representan las marcas de tiempo de milisegundos en relación con el momento en que se realizó la conexión y se solicitó la hora actual del pfodDevice.

Mirando en el boceto generado por Arduino (por ejemplo, pfodFeather52_dateplot.ino), hay tres pequeños bits de código que manejan el lado de Arduino de los gráficos.

La sección de código loop () que maneja la solicitud de tiempo actual {@} de pfodApp

// manejar {@} solicitud} else if ('@' == cmd) {// pfodApp solicitó tiempo 'actual' plot_mSOffset = millis (); // captura milisegundos actuales como marcas de tiempo de datos sin procesar de compensación parser.print (F ("{@` 0} ")); // devuelve `0 como milisegundos de datos sin procesar 'actuales'

Podría simplemente devolver el valor actual de millis (), pero millis () vuelve a 0 cada 49,7 días, lo que haría que la trama salte hacia atrás. Entonces, en su lugar, el código recuerda el valor actual de millis () cuando se realizó la solicitud {@} y devuelve {@ `0}, es decir, una marca de tiempo actual de milisegundos de cero. Luego, al enviar los puntos de datos sin procesar, el boceto utiliza

plot_1_var = analogRead (A0); // leer la entrada para trazar // plot_2_var plot Oculto, por lo que no hay datos asignados aquí // plot_3_var plot Hidden, por lo que no hay datos asignados aquí // enviar datos de trazado en formato CSV parser.print (millis () - plot_mSOffset); // tiempo en milisegundos ….

de modo que la marca de tiempo de milisegundos enviada con los datos comience en 0 y aumente hasta 49,7 días. Si permanece conectado continuamente durante 49,7 días, verá que la trama retrocede ~ 50 días. Desconectar y volver a conectar una vez cada 49,7 días evita esto.

La tercera parte del gráfico de fecha / hora es el mensaje del gráfico.

} else if ('A' == cmd) {// usuario presionó - 'Diagrama de fecha / hora de A0' // en el menú principal de Menu_1 // devuelve el mensaje de trazado. parser.print (F ("{= A0 Voltios ~ E HH: mm: ss | fecha | A0 ~~~ Voltios ||}"));

Cuando el usuario presiona el botón "Gráfico de fecha / hora de A0", pfodApp envía el cmd {A} al pfodDevice y el pfodDevice responde con el mensaje de gráfico, {=… {= A0 Volts ~ E HH: mm: ss | date | A0 ~~~ Voltios ||} que contiene el formato del eje X E HH: mm: ss

Los formatos Java SimpleDateFormat son aceptables aquí. pfodApp Data Logging and Plotting y pfodSpecification.pdf tienen más detalles sobre el mensaje de la trama.

Paso 7: reproducción de los gráficos de fecha / hora en su computadora

De forma predeterminada, pfodApp registra todos los datos crudos entrantes en un archivo de registro en su móvil, a menos que haya desactivado este registro en la pantalla de edición de conexión, consulte pfodAppForAndroidGettingStarted.pdf

Cuando edita pfodApp, aparece un breve mensaje con la ubicación y el nombre del archivo de registro, p. Ej. /pfodAppRawData/pfod_bluefruit52.txt Ese archivo está en formato CSV, delimitado por comas, y después de transferirlo a su computadora (consulte pfodAppForAndroidGettingStarted.pdf para conocer las opciones de transferencia), puede abrirlo en una hoja de cálculo para trazar los datos.

Aquí están las primeras líneas del archivo de registro.

// pfodApp V3.0.360, hora local, UTC, mS por día, pfod bluefruit52 hora actual (mS), pfod bluefruit52 hora actual, // conectado en, 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``

Arriba puede ver la hora 'local' y UTC que pfodApp se conectó al Feather52 y la hora actual en mS que el Feather52 informó a través de la respuesta {@..}. La última columna está en blanco, porque no hay RTC o GPS y, por lo tanto, Feather52 no informó de la hora actual en la hora aaaa / MM / dd.

Para graficar los datos contra el tiempo transcurrido, reste el tiempo actual (mS) de la marca de tiempo de milisegundos y luego divida por el valor de mS por día. Aquí está la hoja de cálculo con la fórmula agregada y el resultado trazado. La hoja de cálculo, a continuación, (pfod_bluefruit52.xls) es una hoja de cálculo de OpenOffice guardada en formato Excel.

En OpenOffice, el gráfico es un gráfico de dispersión y el eje x del gráfico se formateó en HH: MM: SS Nota: los formatos de fecha / hora de la hoja de cálculo NO son los mismos que los formatos de gráfico utilizados por pfodApp. Por ejemplo, en pfodApp, MM son meses y mm son minutos.

Para graficar en función de la fecha y la hora, solo necesita agregar la hora de conexión a la hora de la hoja de cálculo y volver a escribir. (pfod_bluefruit52_date.xls)

Nota: La hora local y UTC se importaron como texto en mi hoja de cálculo, por lo que necesitaba eliminar el 'inicial' antes de usarlos en una fórmula.

Paso 8: Cómo evitar el límite de 49,7 días Millis () y por qué no debería

Como se mencionó anteriormente en ¿Cómo pfodApp traza la fecha / hora desde millis () ?, si permanece conectado continuamente durante más de 49.7 días, las marcas de tiempo de milisegundos volverán a cero. Algunas líneas de código pueden evitar esto, pero no se recomienda.

Primero, cómo evitar la envoltura. Agregue otra variable int sin firmar para realizar un seguimiento del número de veces que las marcas de tiempo se envuelven e imprimen el resultado combinado en HEX.

uint_t mSwrapCount = 0; uint32_t lastTimeStamp = 0;

… Plot_1_var = analogRead (A0); // leer la entrada para trazar // plot_2_var plot Oculto para que no haya datos asignados aquí // plot_3_var plot Oculto para que no haya datos asignados aquí // enviar datos de trazado en formato CSV uint32_t timeStamp = millis () - plot_mSOffset; if (timeStamp <lastTimeStamp) {// timeStamp regresó a 0 mSwrapCount ++; // agregue uno para contar} lastTimeStamp = timeStamp; parser.print ("0x"); parser.print (msWrapCount, HEX); parser.print (timeStamp, HEX); // tiempo en milisegundos en HEX….

Cuando devuelva la respuesta {@.., borre también mSwrapCount.

// manejar {@} solicitud} else if ('@' == cmd) {// pfodApp solicitó tiempo 'actual' plot_mSOffset = millis (); // captura los milisegundos actuales como marcas de tiempo de datos sin procesar de compensación mSwrapCount = 0; // Borrar recuento de envolturas. parser.print (F ("{@` 0} ")); // devuelve `0 como milisegundos de datos sin procesar 'actuales'

Las marcas de tiempo ahora darán el valor 'correcto' para los próximos 40.7 días * 65536 ~ = 7308 años.

pfodApp convertirá automáticamente las marcas de tiempo hexadecimales para trazarlas y las registrará exactamente como se recibieron, es decir, en hexadecimal. En la hoja de cálculo (OpenOffice), usa esta fórmula para convertir la cadena hexadecimal, en A2, a mS (donde A1 es cualquier celda vacía) = HEX2DEC (REPLACE (A2; 1; 2; A1))

¿Por qué no quieres hacer esto?

Como se muestra arriba, es fácil extender las marcas de tiempo mS a más de 50 días. Sin embargo, es probable que no desee hacer eso porque se vuelven cada vez más imprecisos. Un cristal típico de 16Mhz utilizado para crear los resultados milis () en el micro tiene una precisión de ~ 50 ppm (partes por millón). Esto significa que después de 49,7 días, la marca de tiempo de milisegundos puede estar fuera de 3 ½ minutos y eso ignora el efecto de la temperatura en la precisión del cristal.

En períodos de conexión cortos, esta falta de precisión no es un problema, ya que la respuesta {@.. vuelve a sincronizar la marca de tiempo de milisegundos con la fecha / hora del dispositivo móvil en cada reconexión. Sin embargo, si desea permanecer conectado durante largos períodos de tiempo (días) y registrar continuamente los datos, debe usar algo más preciso que el milis () integrado, como un módulo RTC o GPS.

Paso 9: uso de un RTC (reloj en tiempo real)

Hay varios módulos RTC disponibles, uno de los más precisos es DS3231, p. Ej. Módulo DS3231 de Adafruit. La precisión indicada es de +/- 2 ppm sobre 0 a 40 ° C. es decir, ~ +/- 5 seg / mes.

Si desea trazar datos que tengan marcas de tiempo de fecha / hora, p. Ej. 2019/04/19 20: 4: 34, luego debe modificar la {@ respuesta para devolver la fecha / hora actual, p. Ej. {@ `0 ~ 2019/4/19 3: 33: 5}. Aquí hay algunos cambios de código de muestra para aplicar al boceto generado por pfodDesigner para usar un módulo RTC, asumiendo que está usando la biblioteca RTClib y ha agregado el código para inicializar el módulo RTC.

// manejar {@} solicitud} else if ('@' == cmd) {// pfodApp solicitó tiempo 'actual' plot_mSOffset = millis (); // captura milisegundos actuales como marcas de tiempo de datos brutos de compensación parser.print (F ("{@` 0 "}); // devuelve` 0 como milisegundos de datos brutos 'actuales' parser.print ('~'); // cadena de inicio de date / time DateTime now = rtc.now () sendDateTime (& now); // envía aaaa / M / d / H: m: sa parser.print, pasa la dirección & as arg. parser.print ('}'); // fin de la {@ respuesta, por ejemplo, {@ `0 ~ 2019/4/19 3: 33: 5}….

// enviar fecha y hora al analizador printvoid sendDateTime (DateTime * dt) {parser.print (dt-> year (), DEC); parser.print ('/'); parser.print (dt-> mes (), DEC); parser.print ('/'); parser.print (dt-> día (), DEC); parser.print (''); parser.print (dt-> hora (), DEC); parser.print (':'); parser.print (dt-> minuto (), DEC); parser.print (':'); parser.print (dt-> second (), DEC); }

void sendData () {if (plotDataTimer.isFinished ()) {plotDataTimer.repeat (); // reinicia el temporizador de datos de trazado, sin deriva // asigna valores para trazar variables de tus variables de bucle o lee las entradas de ADC plot_1_var = analogRead (A0); // leer la entrada para trazar // plot_2_var plot Oculto, por lo que no hay datos asignados aquí // plot_3_var plot Hidden, por lo que no hay datos asignados aquí // enviar datos de trazado en formato CSV DateTime now = rtc.now (); sendDateTime (y ahora); // envía aaaa / M / d / H: m: s al parser.print, pasa la dirección & como arg. parser.print (','); parser.print (((float) (plot_1_var - plot_1_varMin)) * plot_1_escaling + plot_1_varDisplayMin); parser.print (','); // La parcela 2 está oculta. No se enviaron datos. parser.print (','); // La parcela 3 está oculta. No se enviaron datos. parser.println (); // fin del registro de datos CSV}}

La parte ~ 2019/4/19 3: 33: 5 de la {@ respuesta le permite a pfodApp saber qué piensa el pfodDevice que es la fecha y hora actuales. Su boceto puede enviar datos con marcas de tiempo yMd Hms y pfodApp los trazará como tiempo transcurrido desde el tiempo de conexión O como fecha y hora, según el formato del eje X que especifique.

Al trazar contra la fecha y la hora, la rutina de trazado de pfodApp corrige cualquier 'desviación' en el RTC comparando la hora actual informada de pfodDevice con la hora actual del móvil. Esta corrección también controla que el RTC se establezca en una zona horaria diferente de la zona horaria local de su móvil. Las marcas de tiempo millis () continúan funcionando como en Uso de marcas de tiempo de milisegundos de Arduino, Paso 5 anterior.

Aquí hay una hoja de cálculo de ejemplo de temperaturas ambiente durante un período de 8 días, Office_Temp.xls Cuando se importó el archivo de registro, la primera columna se marcó como YMD para convertir el texto a una fecha / hora. Aún debe eliminar las entradas iniciales de la hora local, UTC y Office Temp para que la hoja de cálculo las interprete como fechas y horas.

Para obtener el mismo gráfico que muestra pfodApp, debe calcular la "Fecha / hora corregida". En este caso, la hora RTC está 2 segundos por detrás de la hora local del móvil, por lo que a cada marca de tiempo RTC se agrega (hora local - Hora actual de Office Temp) para obtener la hora local verdadera.

Para gráficos de tiempo transcurrido, cree una nueva columna que contenga la (marca de tiempo de fecha / hora - la hora actual de Office Time) y utilícela como el eje X en el gráfico (Office_TempElapsed.xls). En realidad, en este caso, pfodApp produce gráficos de tiempo transcurrido más agradables. en días hr: min: seg.

Paso 10: uso de un módulo GPS

Usar un módulo GPS es similar a usar un módulo RTC, excepto que los módulos GPS tienen milisegundos disponibles, los años comienzan en 2000 y faltan los segundos intercalares UTC (consulte https://tycho.usno.navy.mil/leapsec.html) La fecha y la hora del GPS están actualmente 18 segundos por delante de la UTC, en enero de 2018.

La biblioteca de Adafruit GPS para Adafruit Ultimate GPS, a diferencia de la RTClib, no agrega la compensación de 2000 años a los años de GPS, por lo que debe agregarse cuando envíe la fecha y la hora. Además, aunque la biblioteca de GPS proporciona milisegundos que tienen muy buena precisión a largo plazo, no son muy precisos. Las actualizaciones de la hora del GPS son solo una vez cada 100 ms y luego hay un retraso adicional en la recepción de los datos en serie a una velocidad lenta de 9600 baudios y otro retraso en el análisis. Todo lo cual se suma a la precisión de milisegundos cuando se registran las lecturas de datos.

Aquí hay algunos cambios de código de muestra para aplicar al boceto generado por pfodDesigner para usar un módulo GPS, asumiendo que está usando la biblioteca GPS de Adafruit y ha agregado el código para recibir y analizar los mensajes en un objeto GPS.

// manejar {@} solicitud} else if ('@' == cmd) {// pfodApp solicitó tiempo 'actual' plot_mSOffset = millis (); // captura milisegundos actuales como marcas de tiempo de datos brutos de compensación parser.print (F ("{@` 0 "}); // devuelve` 0 como milisegundos de datos brutos 'actuales' parser.print ('~'); // cadena de inicio de date / time sendDateTime (& GPS); // envía aaaa / M / d / H: m: s a parser.print, pasa la dirección & as arg. parser.print ('}'); // final de {@ respuesta eg {@ `0 ~ 2019/4/19 3: 33: 5}….

// enviar fecha y hora al analizador printvoid sendDateTime (Adafruit_GPS * gps) {parser.print (F ("20"); // 20.. año parser.print (gps-> año, DEC); parser.print ('/ '); parser.print (gps-> mes, DEC); parser.print (' / '); parser.print (gps-> día, DEC); parser.print (' '); parser.print (gps- > hora, DEC); parser.print (':'); parser.print (gps-> minuto, DEC); parser.print (':'); parser.print (gps-> segundo, DEC); // parser.print ('.'); si envía milisegundos // si desea enviar mS, debe rellenar el valor gps-> milisegundos con ceros a la izquierda // es decir, 3 debe rellenarse a 003}

void sendData () {if (plotDataTimer.isFinished ()) {plotDataTimer.repeat (); // reinicia el temporizador de datos de trazado, sin deriva // asigna valores para trazar variables de tus variables de bucle o lee las entradas de ADC plot_1_var = analogRead (A0); // leer la entrada para trazar // plot_2_var plot Oculto, por lo que no hay datos asignados aquí // plot_3_var plot Hidden, por lo que no hay datos asignados aquí // enviar datos de trazado en formato CSV sendDateTime (& GPS); // envía aaaa / M / d / H: m: s al parser.print, pasa la dirección & como arg. parser.print (','); parser.print (((float) (plot_1_var - plot_1_varMin)) * plot_1_escaling + plot_1_varDisplayMin); parser.print (','); // La parcela 2 está oculta. No se enviaron datos. parser.print (','); // La parcela 3 está oculta. No se enviaron datos. parser.println (); // fin del registro de datos CSV}}

Al trazar contra la fecha y la hora, pfodApp corrige automáticamente los segundos intercalares. En enero de 2018, la hora del GPS está 18 segundos por delante de la UTC. pfodApp corrige esto comparando la fecha / hora devuelta por el GPS en la conexión, a través de la respuesta {@, con la fecha y hora UTC del móvil. La creación de gráficos en una hoja de cálculo a partir del archivo de registro de pfodApp es la misma que para los módulos RTC, arriba. Agregar la (hora local - Hora actual de Office Temp) a las marcas de tiempo del GPS corrige los segundos intercalares.

Las marcas de tiempo millis () continúan funcionando como en Uso de marcas de tiempo de milisegundos de Arduino, Paso 5 anterior.

Paso 11: Conclusión

El uso de pfodApp en su dispositivo móvil Android le permite trazar datos contra la fecha y la hora o el tiempo transcurrido, utilizando solo la función millis () de Arduino. Con el archivo de registro de pfodApp, puede volver a producir estos gráficos de fecha / hora en una hoja de cálculo. Si su proyecto Arduino tiene un módulo RTC, puede registrar y trazar la fecha y las marcas de tiempo de RTC, corrigiendo automáticamente la 'deriva' de RTC. Si su proyecto Arduino tiene un módulo GPS, puede registrar y trazar sus marcas de tiempo altamente precisas y pfodApp corregirá automáticamente los segundos intercalares faltantes del GPS.

En todos los casos, los datos sin procesar de su proyecto Arduino se registran exactamente como se recibieron, sin corregir. Sin embargo, el archivo de registro de pfodApp incluye datos adicionales para permitirle volver a producir estas correcciones en una hoja de cálculo a partir del archivo de registro descargado.

No se requiere codificación de Android. Los formatos de trazado están todos especificados por pequeñas cadenas de texto en su boceto de Arduino. El pfodDesigner gratuito genera bocetos completos de registro y trazado de datos de Arduino para una amplia variedad de placas Arduino que se conectan a través de WiFi, Bluetooth clásico, BLE y SMS