Ang Arduino ay isang electronic platform na kumukuha ng mga tagubilin mula sa mga user sa anyo ng code na kilala bilang sketch at bumubuo ng output nang naaayon. Upang kolektahin ang mga tagubilin at iproseso ang mga ito nang paisa-isa, gumagamit ang Arduino ng serial buffer. Hawak ng Arduino serial buffer ang papasok na data hanggang sa handa na ang device na iproseso ang mga ito. Minsan kailangan nating i-clear ang serial buffer ng Arduino upang maiwasan ang pagkagambala sa papasok na data. Tingnan natin ito nang mas detalyado.
Arduino Serial Buffer
Kaya, alam nating lahat na nakikipag-usap ang Arduino gamit ang serial communication protocol na kilala bilang USART. Oo, ang Arduino ay may ilang iba pang mga protocol tulad ng SPI, I2C ngunit ang USART ang pinakakaraniwan at madalas na ginagamit na protocol. Kung interesado kang basahin ang lahat ng tatlong protocol ng Arduino, i-click dito .
Kinokolekta ng mga serial buffer ng Arduino ang mga papasok na serial character at pinipigilan ang mga ito hanggang sa maproseso sila ng microcontroller. Ang serial communication ay ang paraan ng paglilipat ng data mula sa isang device patungo sa isa pa. Ang Arduino na gumagamit ng USART hardware sa mga board nito ay nagtitipon ng bawat 8 bits sa isang byte. Pagkatapos ay itabi ang mga byte na ito sa serial buffer, maximum na 64 bytes ang maaaring maimbak sa loob ng Arduino serial buffer.
I-clear ang Arduino Serial Buffer
Ang mga serial buffer ng Arduino ay may limitadong memorya upang mag-imbak ng data kung sakaling mag-overflow ang memorya o malaking halaga ng data ay naroroon sa serial pin, kailangan muna nating i-clear ang serial buffer upang mag-imbak ng papasok na data. Alamin natin ang mga posibleng paraan ng pag-clear sa Arduino serial buffer.
Mga Paraan para I-clear ang Arduino Serial Buffer
Upang magbakante ng serial buffer space upang ma-update ito gamit ang bagong data na sumusunod sa dalawang paraan ay maaaring makatulong:
-
- I-clear ang Serial Buffer gamit ang Serial.flush() Function
- I-clear ang Serial Buffer gamit ang Serial.begin() Function
1: I-clear ang Serial Buffer gamit ang Serial.flush() Function
Kaya, ang unang paraan na makakapag-clear ng Arduino serial buffer ay gumagamit ng Serial.flush() function. Ang function na ito ay kabilang sa Arduino serial library function.
Serial.flush()
Ang Arduino Serial.flush() function ay naghihintay para sa data na ganap na maipadala. Sa halip na itapon ang papasok na data, pinapayagan itong maghintay kaya kapag ang data sa loob ng buffer ay ganap na naipadala pagkatapos ay matatanggap ng Serial buffer ang bagong data.
Tandaan : Pagkatapos gumamit ng Serial.flush() na mga programa ay maaaring tumagal ng mas maraming oras upang maisagawa at mai-print ang output sa serial monitor. Sa ngayon, naghihintay ang Arduino code kapag naipadala na ang lahat ng data upang makapag-imbak ito ng bagong data sa loob ng memorya nito.
Syntax
Serial.flush ( )
Mga Parameter
Isang parameter lang ang kailangan.
Serial: Serial port object
Nagbabalik
Walang ibinabalik ang function na ito.
Halimbawang Code
Narito ang code na isinulat nang hindi gumagamit ng Serial.flush() function:
walang bisang setup ( ) {Serial.magsimula ( 9600 ) ;
unsigned long millis_FlushStart = millis ( ) ; /* Simulan ang code sa pamamagitan ng pag-save ng kasalukuyang Arduino na orasan oras */
Serial.println ( F ( 'Linuxhint.com/Arduino' ) ) ;
Serial.println ( F ( 'Linuxhint.com/RaspberryPi' ) ) ;
Serial.println ( F ( 'Linuxhint.com/Tutorial' ) ) ;
unsigned long millis_FlushStop = millis ( ) ; /* kasalukuyang oras sa puntong ito */
Serial.print ( F ( 'Kailangan nang walang Flush Function' ) ) ;
Serial.print ( millis_FlushStop - millis_FlushStart ) ; /* Mga print oras kinuha ng serial buffer para mag-print ng data */
Serial.println ( F ( 'mga millisecond.' ) ) ;
}
walang laman na loop ( ) {
}
Sa code sa itaas, sinimulan namin ang tatlong magkakaibang mga string at sinimulan ang code sa pamamagitan ng pagkuha ng kasalukuyang oras mula sa millis() function at i-save ito sa isang bagong variable. Kapag na-print muli ang data gamit ang millis() function, ipinapasa namin ang kasalukuyang oras sa isang bagong variable.
Kapag ang parehong oras ay natanggap sa loob ng dalawang variable mayroong pagkakaiba ay magbibigay sa amin ng oras na kinuha ng Arduino upang i-print ang tatlong tinukoy na mga string sa milliseconds.
Sa output terminal makikita ito na tumatagal ng 9ms upang mai-print ang tinukoy na string.
Ngayon sa code na ibinigay sa ibaba ay gagamitin namin ang Serial.flush() function na magpapahintulot sa lahat ng mga string na dumaan at maghintay doon hanggang sa maging malinaw ang serial buffer upang matanggap ang susunod na data. Samakatuwid, aabutin ng dagdag na oras kumpara sa pag-print ng data nang hindi gumagamit ng Serial.flush().
Serial.magsimula ( 9600 ) ;
unsigned long millis_FlushStart = millis ( ) ; /* Simulan ang code sa pamamagitan ng pag-save ng kasalukuyang Arduino na orasan oras */
Serial.println ( F ( 'Linuxhint.com/Arduino' ) ) ;
Serial.println ( F ( 'Linuxhint.com/RaspberryPi' ) ) ;
Serial.println ( F ( 'Linuxhint.com/Tutorial' ) ) ;
Serial.flush ( ) ; /* Naghihintay para sa data na ipapadala pagkatapos ng flush memory na iyon */
unsigned long millis_FlushStop = millis ( ) ; /* kasalukuyang oras sa puntong ito */
Serial.print ( F ( 'Sa Flush Function kailangan ' ) ) ;
Serial.print ( millis_FlushStop - millis_FlushStart ) ; /* Mga print oras kinuha ng serial buffer para mag-print ng data */
Serial.println ( F ( 'mga millisecond.' ) ) ;
}
walang laman na loop ( ) {
}
Ang code na ito ay katulad ng ipinaliwanag namin kanina. Ang pagkakaiba dito ay Serial.flush() function na nagbibigay-daan sa program na maghintay ng ilang dagdag na oras hanggang sa maging malinaw ang serial buffer memory para sa pagtanggap ng susunod na data.
Sa output ay malinaw nating makikita na sa pagkakataong ito ay tumatagal ng 76ms upang mai-print ang tatlong string kumpara sa nauna na tumatagal lamang ng 9ms.
2: I-clear ang Serial Buffer gamit ang Serial.begin() Function
Hanggang ngayon ay ipinaliwanag namin ang function na Serial.flush() upang i-clear ang serial buffer ngunit ang function na ito ay kailangang maghintay para sa data na ganap na maipadala ngayon ang mga tanong ay pumasok sa isip kung paano kung gusto naming i-clear ang papasok na data sa loob ng serial buffer. Ang sagot sa tanong ay simple: magagawa natin ito gamit ang a habang loop gamit ang Serial library function.
Syntax
habang ( Serial.available ( ) )
Serial.basahin ( ) ;
Serial.end ( ) ;
Serial.magsimula ( 9600 ) ;
Code
String val;
walang bisang setup ( ) {
}
walang laman na loop ( ) {
kung ( Serial.available ( ) ) { /* suriin para sa serial data */
val = '' ;
habang ( Serial.available ( ) ) { /* basahin serial data kung magagamit */
char Serial_Data = Serial.basahin ( ) ;
val =val+Serial_Data; /* mag-imbak ng data sa loob ng bagong string */
}
Serial.println ( val ) ; /* i-print ang basahin datos */
Serial.end ( ) ; /* tapusin ang serial communication */
Serial.magsimula ( 9600 ) ; /* malinaw serial buffer */
}
}
Gumagamit ang Arduino ng mga function na Serial.begin() upang simulan ang serial communication sa pamamagitan ng pagtukoy ng baud rate, kapag nasimulan na ang function na ito, nagiging malinaw ang data na dati nang nakaimbak sa memorya ng Arduino. Dito ay susuriin natin ang serial data gamit ang Serial.available() function kapag nabasa na ang data ay mag-iimbak ito sa loob ng bagong string at panghuli gamit ang Serial.begin(9600) tatanggalin natin ang Arduino serial buffer.
Tandaan: Kailangan nating i-flush ang serial buffer dahil tinitiyak nitong naipadala na ang data sa device at hindi lang naghihintay o naka-hold na maipadala.
Konklusyon
Upang i-clear ang Arduino serial buffer para makapag-imbak ito ng bagong data sa loob ng buffer memory Serial.flush() at Serial begin ay maaaring gamitin. Maaari itong magamit upang i-clear ang Arduino serial buffer, ngunit kailangan nating maghintay kapag naipadala na ang lahat ng data upang maiwasan ito, maaari tayong gumamit ng while loop na may Serial.begin() function na maaari ring i-clear ang papasok na data mula sa serial buffer.