Como limpar o tampão serial do Arduino

Arduino é uma plataforma eletrônica que recebe instruções de usuários na forma de código conhecido como esboço e gera saída de acordo. Para coletar as instruções e processá -las uma a uma, o Arduino usa um buffer serial. O tampão serial do Arduino mantém os dados de entrada até que o dispositivo esteja pronto para processá -los. Às vezes, temos que limpar o tampão serial do Arduino para evitar a interferência com os dados recebidos. Vamos ver isso com mais detalhes.

Buffer serial de Arduino

Então, todos sabemos que o Arduino se comunica usando o protocolo de comunicação serial conhecido como USART. Sim, o Arduino tem outros protocolos como SPI, I2C, mas o USART é o protocolo mais comum e frequentemente usado. Se você tem interesse em ler Arduino todos os três protocolos, clique aqui.

Os buffers seriais do Arduino coletam os caracteres em série de entrada e os seguram até que o microcontrolador possa processá -los. A comunicação serial é o método de transferência de dados de um dispositivo para outro. Arduino usando hardware USART em suas placas monta cada 8 bits em um byte. Em seguida, armazene esses bytes no tampão serial, o máximo de 64 bytes pode ser armazenado dentro do tampão serial Arduino.

Buffer serial de Arduino claro

Os buffers seriais do Arduino têm memória limitada para armazenar dados, caso a memória transbordasse ou grande quantidade de dados estivesse lá no pino serial, precisamos limpar o buffer serial primeiro para armazenar dados recebidos. Vamos descobrir possíveis maneiras de limpar o tampão serial Arduino.

Maneiras de limpar o tampão serial do Arduino

Para liberar o espaço de buffer serial, para que possa ser atualizado com novos dados seguintes das duas maneiras de ser úteis:

• • Buffer serial claro usando serial.Função Flush ()
  • Buffer serial claro usando serial.BEGIN () função

1: Clear serial buffer usando serial.Função Flush ()

Portanto, o primeiro método que pode limpar um tampão serial de Arduino está usando uma série.Função Flush (). Esta função pertence à função da biblioteca serial Arduino.

Serial.rubor()

Serial arduino.Função Flush () espera que os dados sejam transmitidos completamente. Em vez de descartar os dados recebidos, ele permite esperar, assim que os dados dentro do buffer forem transmitidos completamente, o buffer serial pode receber os novos dados.

Observação: Depois de usar serial.Os programas Flush () podem levar mais tempo para executar e imprimir a saída no monitor serial. A partir de agora, o código Arduino aguarda assim que todos os dados forem transmitidos para que possam armazenar novos dados dentro de sua memória.

Sintaxe

Serial.rubor()

Parâmetros

É preciso apenas um parâmetro.

Serial: Objeto de porta serial

Retorna

Esta função não retorna nada.

Código de exemplo

Aqui está o código que está escrito sem usar serial.Função Flush ():

Void Setup ()
Serial.começar (9600);
Long Millis_flushstart não assinado = millis (); /*Iniciar o código salvando o tempo atual do relógio do Arduino*/
Serial.println (f ("linuxhint.com/arduino "));
Serial.println (f ("linuxhint.com/Raspberrypi "));
Serial.println (f ("linuxhint.com/tutorial "));
Long Millis_flushstop não assinado = millis (); /*Hora atual neste ponto*/
Serial.imprimir (f ("sem função de descarga necessária"));
Serial.impressão (millis_flushstop - millis_flushstart); /*Imprime o tempo gasto pelo buffer serial para imprimir dados*/
Serial.println (f ("milissegundos."));

Void Loop ()

No código acima, inicializamos três strings diferentes e iniciamos o código tirando o horário atual da função Millis () e salvando -o em uma nova variável. Depois que os dados são impressos novamente usando a função Millis (), passamos no tempo presente para uma nova variável.

Uma vez que o tempo for recebido dentro de duas variáveis, a diferença nos dará o tempo gasto por Arduino para imprimir as três cordas definidas em milissegundos.

No terminal de saída, pode ser visto é preciso 9ms para imprimir a string definida.

Agora, no código dado abaixo, usaremos a série.Função Flush () que permitirá que todas as cordas passem e esperem até que o buffer serial fique claro para receber os próximos dados. Portanto, levará tempo extra em comparação com a impressão de dados sem usar serial.rubor().

Void Setup ()
Serial.começar (9600);
Long Millis_flushstart não assinado = millis (); /*Iniciar o código salvando o tempo atual do relógio do Arduino*/
Serial.println (f ("linuxhint.com/arduino "));
Serial.println (f ("linuxhint.com/Raspberrypi "));
Serial.println (f ("linuxhint.com/tutorial "));
Serial.rubor(); /*Aguarda que os dados sejam transmitidos após essa memória de descarga*/
Long Millis_flushstop não assinado = millis (); /*Hora atual neste ponto*/
Serial.imprimir (f ("com função de descarga necessária"));
Serial.impressão (millis_flushstop - millis_flushstart); /*Imprime o tempo gasto pelo buffer serial para imprimir dados*/
Serial.println (f ("milissegundos."));

Void Loop ()

Este código é semelhante ao que explicamos anteriormente. A diferença aqui é serial.Função Flush () que permite que o programa aguarde algum tempo extra até que a memória do buffer serial fique clara para receber os próximos dados.

Na produção, podemos ver claramente que desta vez leva 76ms para imprimir as três strings em comparação com a anterior, que leva apenas 9ms.

2: Clear serial buffer usando serial.BEGIN () função

Até agora, explicamos a série de função.Flush () para limpar o buffer serial, mas essa função deve esperar que os dados sejam transmitidos completamente agora as perguntas vêm à mente e se queremos limpar os dados que recebem dentro do buffer serial. A resposta para a pergunta é simples: podemos fazer isso usando um enquanto loop com a função da biblioteca serial.

Sintaxe

enquanto (serial.disponível())
Serial.ler();
Serial.fim();
Serial.começar (9600);

Código

String val;
Void Setup ()

Void Loop ()
se (serial.disponível ()) /*Verifique se há dados seriais* /
val = "" ";
enquanto (serial.disponível ()) /*Leia os dados seriados, se disponível* /
char serial_data = serial.ler();
val = val+serial_data; /*Armazene os dados dentro da nova string*/

Serial.println (val); /*Imprima os dados de leitura*/
Serial.fim(); /*Comunicação serial final*/
Serial.começar (9600); /*Buffer serial claro*/

Arduino usa serial.BEGIN () funciona para inicializar a comunicação serial definindo a taxa de transmissão, uma vez que essa função é inicializada, os dados anteriormente armazenados na memória Arduino se tornam claros. Aqui vamos verificar os dados de série usando a série.Disponível () Função Depois que os dados forem lidos, ele armazenará dentro de uma nova string e, finalmente, usando serial.BEGIN (9600) Vamos limpar o tampão serial Arduino.

Observação: Precisamos liberar o buffer serial, pois garante que os dados foram enviados para o dispositivo e simplesmente não estão esperando ou em espera para serem enviados.

Conclusão

Para limpar o tampão serial do Arduino para que ele possa armazenar novos dados no buffer de memória de buffer serial.Flush () e início em série podem ser usados. Ele pode ser usado para limpar o tampão serial do Arduino, mas temos que esperar assim que todos os dados forem transmitidos para evitar isso, podemos usar um loop de tempo com seriado.BEGIN () Função que também pode limpar os dados de entrada do buffer serial.