Plotagem / registro de data / hora do Arduino usando Millis () e PfodApp: 11 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:37

Nenhuma programação Arduino ou Android necessária. Módulos RTC e GPS também suportados. Correção automática para fusos horários, desvio RTC e segundos bissextos perdidos de GPS

Introdução

Este tutorial mostra como usar os carimbos de data / hora do Arduino millis () para traçar dados em relação à data e hora em seu celular Android usando pfodApp.

Nenhuma programação Arduino ou Android necessária. pfodApp também registra dados suficientes para que você possa reproduzir posteriormente os gráficos de data / hora em uma planilha.

NENHUM módulo RTC ou GPS é necessário, no entanto, se seu projeto Arduino tiver um RTC (Real Time Clock) ou um módulo GPS, eles também podem ser usados. Nesses casos, os gráficos de pfodApp serão corrigidos automaticamente para o fuso horário, desvio RTC e segundos bissextos perdidos do GPS. Nenhum código especial do Arduino é necessário para essas correções. Como sempre com o pfodApp, os dados recebidos são registrados exatamente como estão, sem correção; no entanto, o arquivo de log também contém informações suficientes para permitir que você mesmo aplique essas correções ao baixar os logs para o seu computador. Veja abaixo exemplos deste pós-processamento.

Uma grande variedade de formatação do eixo X de data e hora é suportada, todos os quais são completamente controlados por strings de texto curtas em seu esboço do Arduino. Nenhuma programação Android é necessária.

O pfodApp se conectará via WiFi, Bluetooth Classic, BLE e SMS. O pfodDesigner gratuito gera esboços Arduino completos para plotagem / registro de data / hora para conectar-se a uma ampla variedade de placas. Nenhuma programação Arduino é necessária.

Este instrutível usará um Adafruit Feather52 como a placa Arduino de exemplo, que se conecta via BLE.

Este instrutível cobre três casos: - 1) Seu projeto de microprocessador tem apenas timestamps em milissegundos - millis () 2) Seu projeto de microprocessador tem um Real Time Clock (RTC) - pfodApp corrige automaticamente o desvio. 3) Seu projeto de microprocessador tem um módulo GPS - pfodApp corrige automaticamente os segundos bissextos conforme eles ocorrem (atualmente 18 segundos em 2018).

Etapa 1: usando Arduino Millisecond Timestamps, Millis ()

Existem duas partes no uso de milissegundos para data e hora. Um é para representar graficamente os dados em relação ao tempo decorrido ou data / hora e a outra parte é recriar a data e a hora a partir dos registros de data e hora de dados brutos em milissegundos. pfodApp não modifica os dados brutos recebidos do pfodDevice (o micro do Arduino). Ele apenas registra exatamente os bytes recebidos.

Primeiro, use o pfodDesigner gratuito para gerar um esboço do Arduino para seu micro que enviará os milissegundos e as medições de dados para pfodApp para plotagem / registro. Este exemplo cria um menu para a placa Adafruit Feather 52 BLE que lê A0. O tutorial sobre Adafruit Feather nRF52 LE - Controles personalizados com pfodApp segue as etapas do pfodDesigner para criar um menu para o Feather nRF52 que inclui um botão Gráfico, portanto, verifique-o para obter mais detalhes. Neste tutorial, adicionaremos apenas um botão de gráfico e usaremos as novas opções de formato do eixo X para traçar as leituras A0 em relação ao tempo decorrido e data / hora.

A primeira parte deste tutorial passará por usar o pfodDesigner gratuito para criar um gráfico de data / hora de amostra em seu celular Android. Quando estiver satisfeito com a exibição, você pode gerar o esboço do Arduino que irá reproduzi-lo quando você se conectar com o pfodApp. Nenhuma programação Android é necessária e, como o pfodDesigner gera esboços completos do Arduino para uma ampla variedade de placas Arduino, nenhuma programação do Arduino também é necessária.

Etapa 2: Adicionar um gráfico ao menu

Baixe o aplicativo pfodDesigner do Google Play, abra-o e clique em “Iniciar novo menu”

Clique em “Target Serial” e depois no botão “Bluetooth Low Energy” para exibir a lista de 11 placas BLE (role para baixo para ver as outras opções). Selecione em Adafruit Bluefruit Feather52.

Volte ao menu de edição e clique em “Editar prompt” e defina um prompt adequado para este menu, por exemplo, “Feather52” e texto em negrito e tamanho +7. A cor de fundo foi deixada como o branco 'padrão'

Volte e clique em “Adicionar item do menu”, role para baixo e selecione “Botão do gráfico” que abre a tela de edição do botão do gráfico. Você pode fazer qualquer alteração na aparência do botão aqui. Neste caso, o texto do botão foi alterado para “Gráfico de data / hora de A0” e os outros padrões foram deixados como estão.

Isso dá a você um botão no menu que abrirá a tela do gráfico.

Etapa 3: Editando a fonte do gráfico e as etiquetas

Clique no botão “Gráfico de data / hora de A0” para abrir a tela Editando gráficos, onde você pode acessar o rótulo do gráfico, o formato do eixo X, o intervalo de dados do gráfico e (rolando para baixo) as próprias configurações do gráfico. Edite o rótulo do gráfico para algo adequado, por exemplo, “A0 Volts”.

Role para baixo e, para os Plots 2 e 3, abra Edit Plot e clique em Hide Plot para removê-los da exibição do gráfico.

Em seguida, clique em "Editar Plot 1" e defina um rótulo de gráfico (por exemplo, A0), unidades yAxis (por exemplo, Volts), exiba no máximo 3,6 V e conecte ao pino I / O A0.

Role para cima e clique em “Visualização do gráfico” para os 0 pontos de dados de amostra mais recentes, em intervalos de 1 segundo, plotados em relação ao tempo decorrido em minutos: segundos.

Para todos os gráficos de tempo decorrido, as unidades de zero à esquerda não são exibidas, portanto, neste gráfico, apenas aqueles tempos> 1min têm os minutos iniciais mostrados.

Etapa 4: Escolhendo o formato de data / hora

Para gráficos de tempo decorrido, a unidade líder continua aumentando conforme o tempo passa. Para ver um exemplo disso, volte para a tela "Editando Plots" e aumente o intervalo de dados do Plot para 15 minutos (parte inferior desta tela)

Em seguida, clique em Visualização do gráfico para mostrar os mesmos dados de amostra, mas agora com intervalos de 15 minutos entre as amostras. Como você pode ver, a parte dos minutos de mm: ss continua aumentando.

Agora volte e clique no botão do eixo X para mostrar uma pequena seleção de todos os formatos possíveis de dados / hora do eixo X (role para baixo para mais)

Acima está uma seleção de visualizações de gráficos usando diferentes formatos do eixo X.

Os gráficos de data / hora mostrados aqui estão no fuso horário 'local'. Existem também opções de formato para plotar data / hora em UTC. Para um conjunto completo de opções de formato de data / hora possíveis, consulte o pfodSpecification.pfd.

Etapa 5: gerar e testar o esboço do Arduino

Quando estiver satisfeito com o formato de seu gráfico e intervalo de dados, você pode ir para a tela “Editing Menu_1” e rolar para baixo e “Gerar Código” para o quadro de destino escolhido. Aqui está um esboço de amostra para o Adafruit Feather52 usando intervalos de dados de 1 seg e um formato de tempo decorrido mm: ss, pfodFeather52_timeplot.ino

Acima está um gráfico de A0 do Feather52

Alterar o formato para Dia da semana hr: min: seg (~ E HH: mm: ss) e regenerar o código (pfodFeather52_dateplot.ino) dá um gráfico como o segundo acima.

Você pode editar o formato do eixo X diretamente no esboço do Arduino, conforme descrito a seguir.

Etapa 6: Como o PfodApp representa a data / hora em milis ()?

Quando o pfodApp se conecta, ele lembra seu horário 'local' e UTC e solicita os carimbos de data / hora do gráfico atual do pfodDevice (a placa do Arduino). Usando essas informações, o pfodApp pode, então, plotar carimbos de data / hora em milissegundos como o tempo decorrido, ou seja, converter milissegundos em horas minutos seg etc., ou traçar a data e hora que os carimbos de data / hora em milissegundos representam em relação a quando a conexão foi feita e a hora atual do pfodDevice foi solicitada.

Olhando o esboço gerado pelo Arduino (por exemplo, pfodFeather52_dateplot.ino), existem três pequenos pedaços de código que manipulam o lado do Arduino dos gráficos.

A seção de código loop () que lida com a solicitação de hora atual do pfodApp {@}

// lida com {@} solicitação} else if ('@' == cmd) {// pfodApp solicitado hora 'atual' plot_mSOffset = millis (); // captura os milissegundos atuais como timestamps de dados brutos compensados parser.print (F ("{@` 0} ")); // retorna `0 como 'atual' dados brutos em milissegundos

Você poderia simplesmente retornar o valor atual de millis (), mas millis () volta a 0 a cada 49,7 dias, o que faria o gráfico voltar atrás. Portanto, em vez disso, o código lembra o valor atual de millis () quando a solicitação {@} foi feita e retorna {@ `0}, ou seja, um carimbo de data / hora em milissegundo atual igual a zero. Então, ao enviar os pontos de dados brutos, o esboço usa

plot_1_var = analogRead (A0); // leia a entrada para o gráfico // plot_2_var plot Oculto, então nenhum dado atribuído aqui // plot_3_var plot Oculto, então nenhum dado atribuído aqui // envia os dados do gráfico no formato CSV parser.print (millis () - plot_mSOffset); // tempo em milissegundos …

de modo que o carimbo de data / hora em milissegundos enviado com os dados comece em 0 e aumente até 49,7 dias. Se você ficar conectado continuamente por 49,7 dias, verá o gráfico retroceder em ~ 50 dias. Desconectar e reconectar uma vez a cada 49,7 dias evita isso.

A terceira parte do gráfico de data / hora é a mensagem do gráfico.

} else if ('A' == cmd) {// usuário pressionado - 'Gráfico de data / hora de A0' // no Menu principal do Menu_1 // retorna a mensagem de plotagem. parser.print (F ("{= A0 Volts ~ E HH: mm: ss | data | A0 ~~~ Volts ||}"));

Quando o usuário pressiona o botão "Gráfico de data / hora de A0", pfodApp envia o cmd {A} para o pfodDevice e o pfodDevice responde com a mensagem de gráfico, {=… {= A0 Volts ~ E HH: mm: ss | data | A0 ~~~ Volts ||} que contém o formato do eixo X E HH: mm: ss

Os formatos Java SimpleDateFormat são aceitáveis aqui. pfodApp Data Logging and Plotting e o pfodSpecification.pdf têm mais detalhes sobre a mensagem de plotagem.

Etapa 7: Reproduzindo os gráficos de data / hora em seu computador

Por padrão, pfodApp registra todos os dados brutos recebidos em um arquivo de log em seu celular, a menos que você tenha desativado este registro na tela de edição de conexão, consulte o pfodAppForAndroidGettingStarted.pdf

Quando você edita pfodApp, uma breve mensagem é exibida com a localização e o nome do arquivo de log, por exemplo, /pfodAppRawData/pfod_bluefruit52.txt Esse arquivo está no formato CSV, delimitado por vírgulas, e depois de transferi-lo para o seu computador (consulte o pfodAppForAndroidGettingStarted.pdf para opções de transferência), você pode abri-lo em uma planilha para os dados.

Aqui estão as primeiras linhas de um arquivo de log.

// pfodApp V3.0.360, hora local, UTC, mS por dia, hora atual pfod bluefruit52 (mS), hora atual pfod bluefruit52, // conectado em, 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,, Acima você pode ver a hora 'local' e UTC que o pfodApp conectou ao Feather52 e a hora atual em mS que o Feather52 relatou por meio da resposta {@..}. A última coluna está em branco, porque não há RTC ou GPS e, portanto, nenhuma hora atual em aaaa / MM / dd foi informada pelo Feather52.

Para representar graficamente os dados em relação ao tempo decorrido, subtraia a hora atual (mS) do registro de data e hora em milissegundos e divida pelo valor de mS por dia. Aqui está a planilha com a fórmula adicionada e o resultado plotado. A planilha abaixo (pfod_bluefruit52.xls) é uma planilha do OpenOffice salva no formato Excel.

No OpenOffice, o gráfico é um gráfico de dispersão e o eixo x do gráfico foi formatado em HH: MM: SS Nota: os formatos de data / hora da planilha NÃO são os mesmos que os formatos de gráfico usados por pfodApp. Por exemplo, em pfodApp, MM são meses e mm são minutos.

Para traçar a data e a hora, você só precisa adicionar a hora da conexão à hora da planilha e fazer um novo lote. (pfod_bluefruit52_date.xls)

Observação: a hora local e o UTC foram importados como texto na minha planilha, então eu precisei remover o 'à esquerda' antes de usá-los em uma fórmula.

Etapa 8: Como evitar o limite de 49,7 dias de milis () e por que você não deve

Conforme mencionado acima em Como o pfodApp representa a data / hora em milis () ?, se você permanecer conectado continuamente por mais de 49,7 dias, os carimbos de data / hora em milissegundos voltarão a zero. Algumas linhas de código podem evitar isso, mas não é recomendado.

Primeiro, como evitar o envoltório. Adicione outra variável int não assinada para controlar o número de vezes que os carimbos de data / hora envolvem e imprimir o resultado combinado em HEX.

uint_t mSwrapCount = 0; uint32_t lastTimeStamp = 0;

… Plot_1_var = analogRead (A0); // ler a entrada para o gráfico // plot_2_var plot Oculto, então nenhum dado atribuído aqui // plot_3_var plot Oculto, então nenhum dado atribuído aqui // enviar dados do gráfico no formato CSV uint32_t timeStamp = millis () - plot_mSOffset; if (timeStamp <lastTimeStamp) {// timeStamp devolvido a 0 mSwrapCount ++; // adiciona um à contagem} lastTimeStamp = timeStamp; parser.print ("0x"); parser.print (msWrapCount, HEX); parser.print (timeStamp, HEX); // tempo em milissegundos em HEX….

Ao retornar a resposta {@.., limpe o mSwrapCount também.

// lida com {@} solicitação} else if ('@' == cmd) {// pfodApp solicitado hora 'atual' plot_mSOffset = millis (); // captura os milissegundos atuais como timestamps de dados brutos compensados mSwrapCount = 0; // limpar a contagem de envoltórios. parser.print (F ("{@` 0} ")); // retorna `0 como 'atual' dados brutos em milissegundos

Os carimbos de data / hora agora fornecerão o valor 'correto' para os próximos 40,7 dias * 65536 ~ = 7308 anos.

pfodApp irá converter automaticamente os carimbos de data / hora hexadecimais para plotagem e registrá-los exatamente como recebidos, ou seja, em hexadecimal. Na planilha (OpenOffice), você usa esta fórmula para converter a string hexadecimal, em A2, em mS (onde A1 é qualquer célula vazia) = HEX2DEC (REPLACE (A2; 1; 2; A1))

Por que você não quer fazer isso

Conforme mostrado acima, é fácil estender os carimbos de data / hora mS para mais de 50 dias. No entanto, você provavelmente não quer fazer isso porque eles se tornam cada vez mais imprecisos. Um cristal típico de 16 MHz usado para criar os resultados de millis () no micro tem uma precisão de ~ 50 ppm (partes por milhão). Isso significa que depois de 49,7 dias, o carimbo de data / hora em milissegundos pode estar fora de moda por 3 ½ minutos e isso ignora o efeito da temperatura na precisão do cristal.

Em períodos curtos de conexão, essa falta de precisão não é um problema, pois a resposta {@.. sincroniza novamente o carimbo de data / hora em milissegundos com a data / hora do celular em cada reconexão. No entanto, se você deseja permanecer conectado por longos períodos (dias) e registrar continuamente os dados, deve usar algo mais preciso do que os millis () embutidos, como um módulo RTC ou GPS.

Etapa 9: usando um RTC (relógio em tempo real)

Existem vários módulos RTC disponíveis, um dos mais precisos é o DS3231, por exemplo, Módulo DS3231 da Adafruit. A precisão declarada é de +/- 2 ppm acima de 0 a 40C. ou seja, ~ +/- 5 segundos / mês.

Se você deseja representar graficamente dados que possuem carimbos de data / hora, por exemplo, 2019-04-19 20: 4: 34, então você precisa modificar a {@ resposta para retornar a data / hora atual, por exemplo, {@ `0 ~ 2019/4/19 3: 33: 5}. Aqui estão algumas alterações de código de amostra para aplicar ao esboço gerado por pfodDesigner para usar um módulo RTC, supondo que você esteja usando a biblioteca RTClib e tenha adicionado o código de inicialização do módulo RTC.

// manipula {@} solicitação} else if ('@' == cmd) {// pfodApp solicitou tempo 'atual' plot_mSOffset = millis (); // captura os milissegundos atuais como timestamps de dados brutos deslocados parser.print (F ("{@` 0 "}); // retorna` 0 como 'atual' dados brutos em milissegundos parser.print ('~'); // inicia a string de data / hora DateTime now = rtc.now () sendDateTime (& now); // envie aaaa / M / d / H: m: s para parser.print, passe o endereço & como arg. parser.print ('}'); // fim da {@ resposta, por exemplo {@ `0 ~ 2019/4/19 3: 33: 5}….

// envia data e hora para o analisador printvoid sendDateTime (DateTime * dt) {parser.print (dt-> ano (), DEC); parser.print ('/'); parser.print (dt-> mês (), DEC); parser.print ('/'); parser.print (dt-> dia (), 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 (); // reinicie o cronômetro de dados do gráfico, sem desviar // atribua valores para as variáveis do gráfico de suas variáveis de loop ou leia as entradas ADC plot_1_var = analogRead (A0); // ler a entrada para o gráfico // plot_2_var plot Oculto, então nenhum dado atribuído aqui // plot_3_var plot Oculto, então nenhum dado atribuído aqui // enviar dados do gráfico no formato CSV DateTime now = rtc.now (); sendDateTime (& now); // envie aaaa / M / d / H: m: s para parser.print, passe o endereço & como arg. parser.print (','); parser.print (((float) (plot_1_var - plot_1_varMin)) * plot_1_scaling + plot_1_varDisplayMin); parser.print (','); // Plot 2 está oculto. Nenhum dado enviado. parser.print (','); // Plot 3 está oculto. Nenhum dado enviado. parser.println (); // fim do registro de dados CSV}}

A parte 3: 33: 5 de ~ 2019/4/19 da {@ resposta permite que o pfodApp saiba o que o pfodDevice pensa ser a data e a hora atuais. Seu esboço pode então enviar dados com carimbos de data / hora yMd Hms e pfodApp irá plotá-los como o tempo decorrido desde o tempo de conexão OU como data e hora, dependendo do formato do eixo X que você especificar.

Ao representar a data e a hora, a rotina de plotagem pfodApp corrige qualquer 'desvio' no RTC comparando a hora atual relatada do pfodDevice com a hora atual do celular. Essa correção também controla o RTC sendo definido para um fuso horário diferente do fuso horário local do seu celular. Os carimbos de data / hora millis () continuam a funcionar como em Usando carimbos de data / hora em milissegundos do Arduino, Etapa 5 acima.

Aqui está uma planilha de exemplo de temperatura ambiente em um período de 8 dias, Office_Temp.xls Quando o arquivo de log foi importado, a primeira coluna foi marcada como YMD para converter o texto em uma data / hora. Você ainda precisa remover as entradas iniciais da hora local, UTC e hora atual do Office Temp para que a planilha os interprete como datas e horas.

Para obter o mesmo gráfico que o pfodApp mostra, você precisa calcular a “Data / hora corrigida”. Nesse caso, a hora RTC está 2 segundos atrás da hora local do celular, portanto, a cada carimbo de data / hora RTC é adicionado (hora local - hora atual do Office Temp) para obter a verdadeira hora local.

Para gráficos de tempo decorrido, crie uma nova coluna contendo o (carimbo de data / hora - o horário atual do Office Time) e use-o como o eixo X no gráfico (Office_TempElapsed.xls) Na verdade, neste caso, pfodApp produz gráficos de tempo decorrido mais agradáveis em dias h: min: seg.

Etapa 10: usando um módulo GPS

Usar um módulo GPS é semelhante a usar um módulo RTC, exceto que os módulos GPS têm milissegundos disponíveis, os anos começam em 2.000 e a hora não tem os segundos bissextos UTC (consulte https://tycho.usno.navy.mil/leapsec.html) A data e a hora do GPS estão 18 segundos à frente do UTC, em janeiro de 2018.

A biblioteca Adafruit GPS para o Adafruit Ultimate GPS, ao contrário do RTClib, não adiciona o deslocamento de 2.000 anos aos anos do GPS, de modo que isso precisa ser adicionado quando você envia o carimbo de data e hora. Além disso, embora a biblioteca GPS forneça milissegundos com uma precisão de longo prazo muito boa, eles não são muito precisos. As atualizações de tempo do GPS são apenas uma vez a cada 100 ms e, em seguida, há um atraso extra no recebimento dos dados seriais a 9600 bauds lentos e outro atraso na análise. Tudo isso aumenta a precisão de milissegundos ao registrar a data e hora das leituras de dados.

Aqui estão alguns exemplos de alterações de código para aplicar ao esboço gerado pelo pfodDesigner para usar um módulo GPS, supondo que você esteja usando a biblioteca GPS da Adafruit e tenha adicionado o código para receber e analisar as mensagens em um objeto GPS.

// manipula {@} solicitação} else if ('@' == cmd) {// pfodApp solicitou tempo 'atual' plot_mSOffset = millis (); // captura os milissegundos atuais como timestamps de dados brutos compensados parser.print (F ("{@` 0 "}); // retorna` 0 como 'atual' dados brutos em milissegundos parser.print ('~'); // inicia a string de data / hora sendDateTime (& GPS); // enviar aaaa / M / d / H: m: s para parser.print, passar endereço & como arg. parser.print ('}'); // fim de {@ resposta, por exemplo {@ `0 ~ 2019/4/19 3: 33: 5}….

// enviar data e hora para o analisador printvoid sendDateTime (Adafruit_GPS * gps) {parser.print (F ("20"); // 20.. ano parser.print (gps-> ano, DEC); parser.print ('/ '); parser.print (gps-> mês, DEC); parser.print (' / '); parser.print (gps-> dia, DEC); parser.print (' '); parser.print (gps- > hora, DEC); parser.print (':'); parser.print (gps-> minuto, DEC); parser.print (':'); parser.print (gps-> segundo, DEC); // parser.print ('.'); se enviar milissegundos // se quiser enviar ms, você precisa preencher o valor gps-> milissegundos com zeros à esquerda // ou seja, 3 precisa ser preenchido para 003}

void sendData () {if (plotDataTimer.isFinished ()) {plotDataTimer.repeat (); // reinicie o cronômetro de dados do gráfico, sem desviar // atribua valores para as variáveis do gráfico de suas variáveis de loop ou leia as entradas ADC plot_1_var = analogRead (A0); // ler a entrada para o gráfico // plot_2_var plot Oculto, portanto, nenhum dado atribuído aqui // plot_3_var plot Oculto, portanto, nenhum dado atribuído aqui // envia os dados do gráfico no formato CSV sendDateTime (& GPS); // envie aaaa / M / d / H: m: s para parser.print, passe o endereço & como arg. parser.print (','); parser.print (((float) (plot_1_var - plot_1_varMin)) * plot_1_scaling + plot_1_varDisplayMin); parser.print (','); // Plot 2 está oculto. Nenhum dado enviado. parser.print (','); // Plot 3 está oculto. Nenhum dado enviado. parser.println (); // fim do registro de dados CSV}}

Ao traçar a data e a hora, o pfodApp corrige automaticamente os segundos bissextos. Em janeiro de 2018, a hora do GPS está 18 segundos à frente do UTC. O pfodApp corrige isso comparando a data / hora retornada pelo GPS na conexão, por meio da {@ resposta, com a data e hora UTC do celular. A criação de plotagens em uma planilha a partir do arquivo de log pfodApp é a mesma que para os módulos RTC acima. Adicionar a (hora local - hora atual do Office Temp) aos carimbos de data / hora GPS corrige os segundos intercalados.

Os carimbos de data / hora millis () continuam a funcionar como em Usando carimbos de data / hora em milissegundos do Arduino, Etapa 5 acima.

Etapa 11: Conclusão

Usar pfodApp em seu celular Android permite traçar dados contra data e hora ou tempo decorrido, usando apenas a função millis () do Arduino. Usando o arquivo de log pfodApp, você pode reproduzir esses gráficos de data / hora em uma planilha. Se o seu projeto Arduino tiver um módulo RTC, você pode registrar e plotar a data e os carimbos de data / hora RTC, corrigindo automaticamente o 'desvio' do RTC. Se seu projeto Arduino tiver um módulo GPS, você pode registrar e traçar seus carimbos de data / hora altamente precisos e o pfodApp corrigirá automaticamente os segundos bissextos perdidos do GPS.

Em todos os casos, os dados brutos de seu projeto Arduino são registrados exatamente como recebidos, sem correção. No entanto, o arquivo de log pfodApp inclui dados extras para permitir que você reproduza essas correções em uma planilha a partir do arquivo de log baixado.

Nenhuma codificação Android é necessária. Os formatos de plotagem são todos especificados por pequenas strings de texto em seu esboço do Arduino. O pfodDesigner gratuito gera registros de dados Arduino completos e esboços de plotagem para uma ampla variedade de placas Arduino conectadas via WiFi, Bluetooth clássico, BLE e SMS