Internet of Things: Arduino Serial Monitor

Introduction

 
This chapter deals with Arduino Serial Controller,
 
Serial Monitor is what you're going to get in both Arduino IDE and Arduino Site Editor, it's one of the main features that any Arduino sketcher should be aware of.
 

Arduino Serial Monitor
 

A Serial Monitor is a monitoring tool for Serial Communication. As you know, every microcontroller uses a serial port to communicate with the connected computer or other communication modules. Even though we don't have a serial port in our Arduino board, we use the Universal Serial Bus (USB) for the communication. And, Arduino treats the USB as a serial port.
 
The Arduino Serial Monitor is where you give input signals to the Arduino boards to display the performance.
 
The Wikipedia says:
 
Serial communication is the process of sending data one bit at a time, sequentially, over a communication channel or computer bus. This is in contrast to parallel communication, where several bits are sent as a whole, on a link with several parallel channels.
 
Background
 
Serial Monitor is no more than a debugging tool. It lets programmers execute their code in a programmed way where they are aware of "what is happening". You can determine the flow of code and it also allows you to user input via Serial Monitor.
 
Before going to sketch, we should keep in mind that it's a debugging tool and here we will not use any hardware PIN to implement it. Simply, we just need an Arduino board (in my case, I have Arduino UNO).
 
For now, we will try some basic input and output (I/O) operations as shown in the following code.
  1. void setup()   
  2. {  
  3.     // Baud Rate  
  4.     Serial.begin(9600);  
  5.     Serial.println("Hello Arduino");  
  6.     Serial.println("Hey, C# Corner");  
  7. }  
  8. void loop()  
  9. {}  
And you'll get its output through Serial Monitor (Ctrl+Shift+M) or Tools>Serial Monitor and it would be like the following.
 
 
Explanation
 
So, this seems to be something new. We haven't written anything like in our previous chapter. Because we didn't get a chance to do so.
 
The first thing you should do is to define the Baud Rate of Serial Communication. So, what is Baud Rate? It's a data rate (or, communication rate) in bits per second. Here, we are declaring 9600 and implicitly it means 9600 bits per second.
 
It's a default rate for Serial Communication, else, you can choose from 300, 600, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600, or 115200.
 
Next, we have a println() function that prints the string in the Serial Monitor. And, on every execution, it shifts to a new line (in other words every statement is appended with \n).
 
Up to this, we have printed what we were instructed. We will now ask the users what to print it out.
 
There is also a function called print(), but it differs with println(). The basic difference is that it doesn't switch to the next line after every execution. Whereas, println() does after every execution. That's what an extra ln (in other words line) can do. So, the sketch would be like.
  1. byte user_input;  
  2. void setup() {  
  3.     // Baud Rate  
  4.     Serial.begin(9600);  
  5.     Serial.println("Hello Arduino");  
  6.     Serial.println("Hey, C# Corner");  
  7. }  
  8. void loop() {  
  9.     if (Serial.available()) {  
  10.         user_input = Serial.read();  
  11.         Serial.println(user_input);  
  12.     }  
  13. }
And the output would be like this:
 
 
Here, we need the input as “Ravi” and the Serial Monitor accepts my string and parses (converts) it into a byte data type since we have declared user_input as a byte type. And, it converts "R", "a", "v", "i" to the respective ASCII values since the byte data type stores only ASCII values.
 
Note: "R" is equivalent to 82, "a" equivalent to 97, "v" equivalent to 118 and "i" equivalent to 105.
 
What if I want to print in character mode instead of ASCII codes? So, for this, we have a function called write(), that accepts byte values and returns characters.
  1. byte user_input;  
  2. void setup() {  
  3.     // Baud Rate  
  4.     Serial.begin(9600);  
  5.     Serial.println("Hello Arduino");  
  6.     Serial.println("Hey, C# Corner");  
  7. }  
  8. void loop() {  
  9.     if (Serial.available()) {  
  10.         user_input = Serial.read();  
  11.         Serial.write(user_input);  
  12.     }  
  13. }  
The rest of the code will the remain same except the Serial.write(user_input) function. Now, it will show it differently as in the following:
 
 
Note: In the preceding code, we have used available() to check whether the Serial Port is ready or not for accepting user input.
 
So, next, we will try to parse Serial.read() to char type data.
 
The Sketch would be like:
  1. void setup() {  
  2.     // Baud Rate  
  3.     Serial.begin(9600);  
  4.     Serial.println("Hello Arduino");  
  5.     Serial.println("Hey, C# Corner");  
  6. }  
  7. void loop() {  
  8.     if (Serial.available()) {  
  9.         char input = Serial.read();  
  10.         Serial.println(input);  
  11.     }  
  12. }
And, the output is as expected.
 
 
In spite of char, you can use int to get an integral value.
 
That’s all for this chapter. I hope you enjoyed reading!!
Author
Abhishek Kumar Ravi
Abhishek Kumar Ravi
0 11.5k 4.5m