arduino, eletrônica, robotica...
Duvida sobre o tempo de execução da função Serial.parseInt()
Pessoal, boa noite,
eu estava desenvolvendo um pequeno código, e ao testa-lo, verifiquei que usando a função
Serial.parseInt(), o tempo de execução era muito grande.
Resolvi fazer então um código que somente usava esta função, e imprimi o millis()
antes e depois da função.
Usando o UNO, verifiquei que o tempo é de +- 1000ms (1seg),
Aí resolvi escrever um código que usava o Serial.read() ao invés de Serial.parseInt(), e
calculei o valor para obter o inteiro dos números digitados.
Este programa roda em +- 568 microssegundos +-(0,0006) segundos,
e fornece o mesmo resultado.
Será que alguém sabe a razão deste tempo grande na função Serial.parseInt()?
Anexo programa de teste.
Rui
- Anexos
-
-
Parse_ou_Read.ino, 1 KB
-
Respostas a este tópico
-
Permalink Responder até mineirin RV em
-
Oi Sr I, boa noite,
obrigado por sua atenção, não estou mandando dar um parseint no millis().
Eu estou usando números inteiros digitados no monitor serial.
Eu testei com um numero (1), dois números (12) e 3 números (123). O tempo foi o mesmo.
O parseInt está depois do serial.print, que só coloquei aquele print millis para saber qto tempo
levava.
Mesmo retirando as duas linha que imprimem o millis(), o tempo é tão grande e perceptível,
que tenho esperar para que possa usar os caráteres digitados.
Eu li este tópico do site do arduino, e achei incoerente esta afirmação, pois o comando é
parseInt (Int ), mas retorna um long.
Int no site do arduino https://www.arduino.cc/en/Reference/Int
On the Arduino Uno (and other ATMega based boards) an
intstores a 16-bit (2-byte) value.This yields a range of -32,768 to 32,767 (minimum value of -2^15 and a maximum value of (2^15) - 1).
Long no site do arduino: https://www.arduino.cc/en/Reference/Long
Long variables are extended size variables for number storage, and store 32 bits (4 bytes), from
-2,147,483,648 to 2,147,483,647.
Novamente, obrigado por sua atenção.
Rui
-
Permalink Responder até imhugo em
-
Oi Rui, vc tem razão, até apaguei a primeira resposta minha.
Experimenta digitar 1a ou 12a ou 123a (isto é, digite um caracter que não seja número ao final do seu número)
Procure notar se o parseInt fica mais rápido e diga pra nós qual o valor que retornou.
Veja o que diz o manual do site arduino ( https://www.arduino.cc/en/Reference/ParseInt ):
parseInt() returns the first valid (long) integer number from the serial buffer. Characters that are not integers (or the minus sign) are skipped.
In particular:
Initial characters that are not digits or a minus sign, are skipped;
Parsing stops when no characters have been read for a configurable time-out value, or a non-digit is read;
If no valid digits were read when the time-out (see Serial.setTimeout()) occurs, 0 is returned;
Basicamente, se o parseInt encontrar um caracter não numérico, ele pára;
Mas se não encontrar um caracter não numérico, ele fica aguardando até atingir o tempo limite (time-out)
-
-
Oi Sr. I, bom dia,
obrigado novamente por sua atenção.
Realmente se digitar um carácter não decimal após os decimais o processamento
fica mais rápido.
O tempo fica entre 4 e 5 ms, mesmo assim ainda muito maior do que o outro código
que eu escrevi. (0,6)ms.
Rui
-
Permalink Responder até Jose Augusto Cintra em
-
Olá Rui!
Realmente, serial.parseInt precisa se preocupar com o timeout e serial.read, não. Para isso ele deve usar o TIMER0.
Além disso o parseInt processa mais coisas, pois ele se encarrega de montar o número lido, enquanto que no serial.read() quem faz isso é o programador.
Por isso, acho que serial.read() sempre será mais rápido que serial.parseInt().
Outra coisa que você poderia testar seria colocar um timeout grande, por exemplo, 1 minuto.
Quando você digitar ENTER na serial, para ele será um valor não numérico e irá encerrar a leitura antes de completar o timeout.
-
-
Oi JAC, bom dia.
Obrigado por sua atenção.
Realmente o serial.read é mais rápido mesmo.
O tempo de serial.read somado ao tempo para montar o número no código que usei,
é cerca de 7 vezes mais rápida do que o processo utilizando o serial.parseint com
uma letra no final e 1700 vezes mais rápida se digitar somente dígitos decimais.
Abraços,
Rui
-
Permalink Responder até José Gustavo Abreu Murta em
-
Pesquisando sobre o assunto , pois nunca usei esse comando Serial.parseInt().
https://www.arduino.cc/en/Reference/ParseInt
Descrição
parseInt () retorna o primeiro número inteiro válido (longo) do buffer da console serial. Caracteres que não são números inteiros (ou o sinal de menos) são ignorados.
Em particular:
Caracteres iniciais que não são dígitos ou um sinal de menos, são ignorados;
A analise pára quando nenhum caracter for lido por um tempo limite configurável, ou um não-dígito é lido;
Se não forem lidos dígitos válidos dentro do tempo de time-out (ver Serial.setTimeout ()) , 0 é retornado;
Serial.parseInt () herda da classe de utilitário Stream.Sugiro que estude o fonte da IDE para entender por que demora tanto - não encontrei o fonte ainda desse comando.
Pergunta - como é definido esse time-out ? Talvez seja isso que provoca a lentidão...
Abraços
-
-
Oi JGAM, bom dia.
Obrigado por seu comentário.
É um ponto interessante. Vou verificar se descubro como modificar este time-out.
Mas mesmo digitando um carácter não numérico, que interrompe a contagem do time-out,
o tempo de conversão ainda é muito maior que o code que utilizei.
Abraços,
Rui
-
-
O timeout padrão é de 1 segundo.
Par mudá-lo, use Serial.setTimeout(time)
Você pode tentar colocar um timeout menor: setTimeout(100).
Mas eu acho que aumentando o timeout e digitando ENTER para separar as leituras terá um efeito melhor.
-
-
Oi JAC, bom dia.
Muito obrigado pela expanação.
Rui
Bem-vindo a
Laboratorio de Garagem (arduino, eletrônica, robotica, hacking)
© 2024 Criado por Marcelo Rodrigues.
Ativado por
