Arduino Serial

Ah, Arduino, I remember when you were just crawling around and blinking LEDs. Now you're ready to learn how to speak! In this lesson we'll learn how to use the Serial Library to communicate from the Arduino board back to the computer over the USB port. Then we'll learn how to manipulate numbers and data.

For this lesson we won't be using the shield, so simply remove it (keeping the mood light LEDs on it you'd like). The shield doesn't contain any programs or data, it is just our way of connecing up the LEDs and resistors. We'll use the shield again but for now, we can examine the RX and TX LEDs on the main Arduino board which will help you with debugging

  1. The Arduino programming language Reference, organized into Functions, Variable and Constant, and Structure keywords. - Arduino Reference This page is also available in 2 other languages.
  2. For example the Arduino Mega has different Serials (Serial, Serial1, Serial2, Serial3) and the Arduino Zero has a native USB port only (use SerialUSB instead of Serial). On the Raspberry Pi, you can connect many Serial devices on the USB ports.

Serial data transfer is when we transfer data one bit at a time, one right after the other. Information is passed back & forth between the computer and Arduino by, essentially, setting a pin high or low. Just like we used that technique to turn an LED on and off, we can. The arduino IDE has so many built-in functions which help in the serial communication process and the details of a few functions for initializing the hardware and sending the data to the serial port are discussed in the previous project how to send data from the serial port of arduino. The functions like Serial.begin,Serial.print and Serial.

Libraries are great places, and not yet illegal in the United States! If you ever need to learn how to do something, like say fix a motorcycle, you can go to your local library and take out a book. Sure you could buy the book but the library is nice because as a resource you can get the book whenever you need it, keeping your house uncluttered.

Software Libraries are very similar. We already studied what a procedure is, in lesson 3: a procedure is a list of things to do. A library is a big collection of procedures, where all the procedures are related! If you, say, want to control a motor, you may want to find a Motor Control Library: a collection of procedures that have already been written for you that you can use without having to do the dirty work of learning the nuances of motors.

The library we will be using is the Serial Library, which allows the Arduino to send data back to the computer:

Serial may sound like a tasty breakfast food, but its actually quite different. The word serial means 'one after the other.' For example, a serial killer doesn't stop with one murder, but stabs many people one after the other. Serial data transfer is when we transfer data one bit at a time, one right after the other.

Information is passed back & forth between the computer and Arduino by, essentially, setting a pin high or low. Just like we used that technique to turn an LED on and off, we can also send data. One side sets the pin and the other reads it. It's a little like Morse code, where you can use dits and dahs to send messages by telegram. In this case, instead of a long cable, its only a few feet.

This is as good as Microsoft Visio can do, yay!

(Now, people who are all geeked-out will probably get angry at this point because I'm simplifying things. Well guess what, its an Arduino tutorial, not a OSI Physical Network Architecture tutorial.)

The world isn't run by weapons anymore, or energy, or money. It's run by little ones and zeroes, little bits of data. It's all just electrons. - Sneakers

Now is a good time to review how data is measured. For example, we measure weight with 'ounces' and 'pounds' (or grams and kilograms) and distances with 'inches,' 'feet,' and 'miles' (or centimeters, meters and kilometers). Information has its own system of measurements:

A single bit is either a zero or a one.
You can group bits together into 8 bits which is 1 byte.
1024 bytes (8192 bits) is one Kilobyte (sometimes written KB).
1024 KB (1048576 bytes) is one Megabyte (MB)
1024 MB is 1 Gigabyte (GB)

An interesting thing to note is while 1000 grams is a kilogram, nearly all computer systems consider 1024 bytes to be a kilobyte. That is, a 1.0 Kilobyte file on your computer is 1024 bytes:

Quick quiz!

If your hard disk is 200 Gigabytes, how many bytes is that? Use a calculator with lots of digits!
Highlight the text below for the answer
200 GB * 1024 = 204800 MB
204800 MB * 1024 = 209715200 KB
209715200 KB * 1024 = 214748364800 bytes!

Hard drive makers are quite sneaky, you'll notice that they define GB as being 1000 MB, and 1 MB = 1000 KB, etc. Given this fact, how many bytes can you really store in your 200GB drive?
Highlight the text below for the answer
200 GB * 1000 = 200000 MB
200000 MB * 1000 = 200000000 KB

How much less storage do you get thanks to the marketing guy who came up with this trick?
Highlight the text below for the answer
About 4.6% less than you'd expect

We've actually used the Serial communications capability already quite a bit..that's how we send sketches to the Arduino! When you Compile/Verify what you're really doing is turning the sketch into binary data (ones and zeros). When you Upload it to the Arduino, the bits are shoved out one at a time through the USB cable to the Arduino where they are stored in the main chip.

Arduino serial begin

Next time you upload a sketch, look carefully at the two LEDs near the USB connector, they'll blink when data is being transmitted. One blinks when the Arduino is receiving data (RX) and one blinks when the Arduino is transmitting data (TX)

Enough chatting amongst ourselves, its time to get the Arduino talking. Our first sketch is going to be the hello world! program. When it starts up, it will say 'hello world!'

Create a New Sketch.. and save it as HelloWorld

Into the new sketch, copy and paste the following source code, then save it

OK first thing to notice is that there's nothing in the loop procedure! We've gutted it..and put some stuff into the setup procedure.

Even if we have nothing in the setup or loop procedures, the Arduino requires them to be there. That way it knows you really mean to do nothing, as opposed to forgetting to include them!

The first line of code in the setup procedure is this one:

We definately see that there is a Serial thing going on, and it looks like there is a procedure call as well. This is a library procedure call. The library is called Serial and inside the library is a procedure called begin.

(input values)

If there's no library name, it means that the procedure is in the 'default' collection of procedures we use. For example, delay() is so common, the designers of the Arduino software didn't bother putting it into a library.

So there's some mystery procedure that's called begin, well it's not too tough to figure out what it might do. It's the procedure that gets the Serial stuff ready. But what's the 9600 about?
The comment says 9600 bps, and just so you know bps stands for bits-per-second (we will refer to this as the baud rate)
If you have broadband connection, you may remember reading somewhere that it has, say 350 kbps download rate. This is how fast the connection can read and write bits on the wire. (Needless to say, your broadband connection can transfer data a lot faster than an Arduino!)

OK so Serial.begin sets up the Arduino with the transfer rate we want, in this case 9600 bits per second.

Lets move on to the next line.

This line also uses the Serial library, this time it's calling a procedure called println which is just a shorthand for 'print line'. Note that the 6th letter in println is the letter L not the number 1. This time the input is a quotation, the line of text we would like it to print. We use two ''s (double quotes) to indicate the beginning and end of a line of text.

Quick quiz!

  • If the Arduino transfers data at 9600 bits per second and you're sending 12 bytes of data, how long does it take to send over this information?
    Highlight the text below for the answer
    12 bytes of data equals 12 * 8 = 96 bits of data. If we can transfer 9600 bits per second, then 96 bits takes 1/100th of a second!
  • If the Arduino transfers data at 19200 bits per second (19200 baud) and you're sending 12 bytes of data, how long does it take to send over this information?
    Highlight the text below for the answer
    This is twice as fast as before, so it will take half the time, about 1/200th of a second.

Good, now compile the sketch and upload it to your Arduino..

And then..nothing???

It looks like not much is going on here. Somewhat disappointing since we had so much fun with blinking colored lights before. The trick here is that while you can see blinking lights quite easily, seeing serial data requires a monitor, which like your display monitor will show us what data is being transfered.

Arduino serial monitor

Lucky for us, there's a serial monitor built into the Arduino software!

I'm not quite sure what the icon means, but regardless if you click that button you will replace the black Program Notification area with a Serial Monitor. it!

What happens next is, sadly, quite dependent on which kind of Arduino you have

WindowsMac OS X Linux
NGArduino does not reset.Arduino does not reset.Arduino does not reset.
DiecimilaArduino resets, starts the sketch a few seconds later Arduino resets, starts the sketch a few seconds later Arduino resets, starts the sketch a few seconds later

In the very common case of having a Diecimila Arduino, the serial monitor will auto-reset the Arduino. The sketch will start up a couple of seconds later

Otherwise, the Arduino does not reset itself. Either way, once you've switched to the serial monitor, press the reset button. If you have an NG Arduino you'll have to wait 7 seconds for the sketch to start.

Voila! It is our sketch!

If you ever find that you're getting a whole lot of gibberish instead of proper text, make sure that you have the correct baud rate selected in the drop down menu of the Serial Monitor. Note that this communication baud rate is indepedent of the upload process, which is fixed at 19200 bps.

Next, try pressing the reset button a few times to make more Hello Worlds! appear. If you have an NG, this may be a bit annoying but do it anyways.

Each time you reset the Arduino, it performs the setup procedure, and prints out Hello again. If you look closely at the Arduino, you will also see the little TX LED blink just as it prints out this message. That's your indication that data was sent.

When you println you are sending data from the Arduino to the computer. The Send button (and the text input next to it) are used to send data to the Arduino. We aren't going to be using it in this lesson so don't be surprised that it doesn't do anything when you click it!

20 GOTO 10

Our next sketch will be a minor modification of this one. Instead of printing out Hello World just once, we'd like it to print it out over and over and over again.

Quick quiz!

  • What simple modification should we perform to make the Arduino print Hello World over and over again?
    Highlight the text below for the answer
    Simply move the Serial.println('Hello world!'); statement from the setup procedure to the loop procedure.

Perform this modification and then compile and upload the new hyper-hello sketch. Then start up the serial monitor. You will see Hello World! scroll by super fast!

Quick quiz!

  • Whats going on with the TX LED?
    Highlight the text below for the answer
    It's lit, not blinking
  • Try waving the Arduino around in a dark room, what do you see?
    Highlight the text below for the answer
    There are little dotted light trails
  • What's going on here? Hint: Remember lesson 2?
    Highlight the text below for the answer
    The data is being transmitted so fast, that we can't see the TX LED's sending data many times a second!

Make the Arduino chill out a little by adding a one second delay to the sketch, so that it only prints out Hello World once a second.

Now you should spend some time playing with println and making it display a message of your choice! Perhaps add some more println statements in order to make the message longer?

Math is hard, let's try programming!

We've played around with printing out phrases, but it turns out we can also print out numbers pretty easily too.

Try out this sketch on your Arduino

Note that we're using 2 procedures here, the original println and now also print. The print procedure is just like println except it does not print out a 'carriage return' at the end, starting a new line. You can experiment with changing the print's to println's and looking at the Serial Monitor output to verify this for yourself.

Here's whats going on in the Arduino with this sketch. For example, lets look at this line:

Arduino Serial Api


We've seen that if you use a quoted line of text as input to println procedure, it will display that text. In this case you can see that if you use a variable to println it will look up what that variable contains and print that out!

It turns out that the Arduino is smart enough to also do math when asked:

In this case, the Arduino looks at what the input to println is, and finds its actually a calculation. It looks up what a is (5) and what b is (10) and then adds them together (+) and then uses that as the value to send to println

Note that for now, we can only do math using integers, which if you recall, are whole numbers. That means we can't yet print out numbers like 3.14 or 1.5.

I could go on and on about operators, its all very important stuff, but many people have written good tutorials on this topic already so I'm going to send you off to read them there!

  • A C++ tutorial (this one's pretty nice, just ignore the cout stuff which is C++'s way of printing out values)
Pythagorean party

Let's make our first simple calculator, to calculate a hypoteneuse. If you remember from grade school, if you have a right-triangle, the hypoteneuse h can be calculated from the lengths of the two legs, c1 and c2 (which we'll call a & b)

a2 + b 2 = h 2
h = (a2 + b2)

The first thing that's new here is this line at the very beginning of the sketch:

Which basically says 'We'd like to use the math procedures, which are in a library that requires us to include the file math.h where the sqrt procedure lives'. Just ignore it for now, it's not important.

The second thing that's different here is that when we create the variable h we don't assign it a value.

It turns out that this is totally OK, it just means that we don't know what h is going to store yet, because we're going to calculate it later. Since it's not assigned to a value upon creation, the Arduino just creates the box, the stuff inside is whatever was in left over in memory.

Default values

If you don't assign a value to a variable, it could be any value. Make sure you don't try to use the variable before you assign it a value!

Later on in the sketch, we assign it the value.

In this line, we square a and b and then add them together, then we call the sqrt() procedure (which does exactly what you may think), to take the square root. Then we assign that to the variable h.


Whatever was in h before is lost, replaced by the new value.

You can nest procedures and functions all you want, calling a procedure on the return value of another procedure.

Quick quiz!

  • Lets say you have a variable 'foo' which contains a number. You'd like to find the square root of the square root of this number. What line of code would print out this value?
    Highlight the text below for the answer
    Serial.println( sqrt( sqrt(foo) );
    First take the square root of foo, then take the square root of that and then use that value as the input to println

Now its your turn to create a calculator.
You'll create a Ohm's law calculator. Ohm's law says that Voltage = Current * Resistance. (This is a pretty useful law which forms the basis of electronics, and we'll study it in depth more later.) Starting with two variables, i for current and r for resistance, have it print out the amount of voltage that can be measured accross the resistor.

Let's write a program that will do that hard drive size calculation we did before. We'll start with the hard drive size in GB, and print out how many MB there are.

We'll start simple, just printing out the drive size in GB

Copy and paste this sketch into Arduino software and name the sketch DriveCalc. Then compile and upload it.

OK, lets add a section of code that will print out the number of Megabytes in the hard drive. Chic task chair.

This time if you compile and upload it you should get

Which is correct, yay! Now try a few different whole numbers for the drive size, from 1 GB to 100 GB.

You may notice that if you put in a 100GB drive size, something very, very strange happens:

A 100GB drive should have 102400MB in it, not some negative number. What's going on here?

What's happening is that we have an overflow problem. Think about your car odometer. The odometer has only 4 digits, it can display 0 miles to 9999 miles travelled. If you travel 10000 miles, the odometer will 'roll over' to 0 again, and from then on it will display an incorrect value.

Keeping that in mind, remember in lesson 2 we said that when we define a variable we also define the box-type of the variable? The box is where we store the data, in this case the type is int. It turns out that an int type can store only 2 bytes.

Quick quiz!
How many bits are in 2 bytes?
Highlight the text below for the answer
There are 8 bits in 1 byte so 2 bytes is 16 bits

To figure out how big a number we can store in a 2 byte-sized box use a calculator and take 2 to the power of the number of bits (since each bit can store 2 values, 0 or 1). Then we subtract 1 because like in the car odometer, you can't actually display the final value, 10000. So, in this case the largest number is 216 - 1 = 65535. Since the number we're trying to store (102400) is larger than that, we see that 'rollover.'

OK let's fix it! All we need to do is change the variable type so that it can store more than 2 bytes of data. Here is a short list of types we can use.

It looks like we want to use the long type. So lets make that change

Compile and upload this sketch..then run the Serial Monitor..

Uh oh, we didn't actually fix the problem!

How frustrating, we did the right thing and it still didn't work. The problem we have now is although the boxes are the right size, we're not handling them well.

If you look at this line, what's happening here is that the Arduino looks up the value of the variable drive_gb to get 100. Then we multiply 100 by 1024 to get 102400 and put that in the drive_mb box. Except the way that the Arduino software does this is that it creates a temporary variable the same size as drive_gb to store that calculation result before it sticks it into drive_mb. So basically we are still getting an overflow, except now its happening as we do the calculation.

Here is one way to fix this insiduous bug:

Now when we do the calculation, the temporary result is stored in a box the same size as drive_mb (a long) instead of an int.

Compile and upload this sketch to try it out

There you go, now its working!

It turns out that I wasn't completely honest in the previous section when I described all the different types. There's another important fact to know, and that has to do with storing negative numbers.

We know that a variable that is 2 bytes large (16 bits) can store 216 different values. We assumed before that these values were 0 - 65535 inclusive. But then how do we store negative numbers? It turns out that there are two kinds of variables, signed and unsigned.
Signed variables can have a positive or negative value, so you can store negative numbers.
variables can only store positive numbers.

By default, variables are signed.

TypeSize (bits)Size (bytes) Minimum Value Maximum Value
Arduino Serial

Quick quiz!

Arduino Serial Write

  • Lets say you have a program that stores the age of a human in years (which so far is no more than 122), whats a good data type to use?
    Highlight the text below for the answer
    You probably want to use a byte type
  • Lets say you want to store the age of a human in seconds, what is an appropriate data type now?
    Highlight the text below for the answer
    110 years = 3468960000 seconds. You'll need to store this in an unsigned long variable.

Why Types?

OK so you're probably wondering: 'This is such a pain, why bother with different size types? Lets just have every variable be as big as possible and we'll never have roll-over problems.'

Well, on your desktop computer, with gigabytes of memory (RAM), this is a reasonable thing to do. However, the tiny tiny computer in the Arduino has a grand total of 1 Kilobyte of memory. And some of that is used for background stuff you don't see. For small sketches sure you can make everything a long and be done with it, but if you have a bigger sketch, you'll run out of memory really fast and then you'll have major problems. So in this case, every byte counts!

What's weird about signed numbers is that if you reach the end of the positive value range you'll rollver into the negative values.

For example, lets say you have a signed int. If you have the value 32767 in that variable, and you add 1 to the variable, you'll actually rollover to -32768.

This sketch will test out this fact:

Compile and upload to run the test.

Quick quiz!

  • Let's say we have a variable that is byte type, it's signed by default. It starts out with the value 127 and we add one to the variable, what will the new variable value be?
    Highlight the text below for the answer
    It's a signed variable so it will roll over to -128
  • Let's say now it is an unsigned byte type, what happens now?
    Highlight the text below for the answer
    Since it is unsigned, it can store much more data, so it will be able to hold the value 128.
  • If we have an unsigned byte and it starts out with the value 250 and we add 10, what will the value be?
    Highlight the text below for the answer
    Even though thie variable can store a lot, it can't store more than the number 255, so it will rollover and we'll end up with the number 4.

Now it's your turn!

Write some sketches that will help you understand variable sizes, try creating variables of different types and signedness and adding and subtracting.

Although this lesson part seems quite boring, and severely lacking in blinky lights, understanding this stuff now will save you from a lot of headaches later when you have data overflows and your program is all wonky and you're really frustrated because you can't figure out why. (Trust me on this one!)

Wrapping up, the final project!

Now its time for you to expand the drive size calculator. Starting with the DriveCalc sketch, modify it so that it will also calculate how many KB are stored in the hard drive. Test it out with a couple different drive sizes.

Once you've got that working, modify it again so that it will also display how much space the drive actually holds thanks to the sneaky math-trick that manufacturers use. Have the sketch display how much storage space is 'missing' (in KB) as well.

Here's one possible solution:


Good work, you got through one of the more boring lessons. In this lesson you learned how to print text and data to the Serial Monitor. This is essential for debugging future projects! You also learned about data types and storage and how to use the Arduino to calculate stuff.



So, you've blinked some LEDs with Arduino, and maybe you've even drawn some pretty pictures with Processing - what's next? At this point you may be thinking, 'I wonder if there's a way to get Arduino and Processing to communicate to each other?'. Well, guess what - there is! - and this tutorial is going to show you how.

In this tutorial we will learn:

  • How to send data from Arduino to Processing over the serial port
  • How to receive data from Arduino in Processing
  • How to send data from Processing to Arduino
  • How to receive data from Processing in Arduino
  • How to write a serial 'handshake' between Arduino and Processing to control data flow
  • How to make a 'Pong' game that uses analog sensors to control the paddles

Before we get started, there are a few things you should be certain you're familiar with to get the most out of this tutorial:

  • Some basic familiarity with Processing will be useful, but not strictly necessary.

Looking for the right Arduino?

Check out our Arduino Comparison Guide! We've compiled every Arduino development board we carry, so you can quickly compare them to find the perfect one for your needs.

From Arduino..

Let's start with the Arduino side of things. We'll show you the basics of how to set up your Arduino sketch to send information over serial.

  • First things first. If you haven't done so yet, download and install the Arduino software for your operating system. Here's a tutorial if you get stuck.
  • You'll also need an Arduino-compatible microcontroller and an appropriate way to connect it to your computer (an A-to-B USB cable, micro USB, or FTDI breakout). Check this comparison guide if you're not sure what's right for you.

Ok. You should by this point have the Arduino software installed, an Arduino board of some kind, and a cable. Now for some coding! Don't worry, it's quite straightforward.

  • Open up the Arduino software. You should see something like this:

The nice big white space is where we are going to write our code. Click in the white area and type the following (or copy and paste if you feel lazy):

This is called our setup method. It's where we 'set up' our program. Here, we're using it to start serial communication from the Arduino to our computer at a baud rate of 9600. For now, all you need to now about baud rate is that (basically) it's the rate at which we're sending data to the computer, and if we're sending and receiving data at different rates, everything goes all gobbledy-gook and one side can't understand the other. This is bad.

Arduino Serial

After our setup() method, we need a method called loop(), which is going to repeat over and over as long as our program is running. For our first example, we'll just send the string 'Hello, world!' over the serial port, over and over (and over). Type the following in your Arduino sketch, below the code we already wrote:

Arduino Serial.println

That's all we need for the Arduino side of our first example. We're setting up serial communication from the Arduino and telling it to send data every 100 milliseconds. Your Arduino sketch should now look something like this:

All that's left to do is to plug in your Arduino board, select your board type (under Tools -> Board Type) and your Serial port (under Tools -> Serial Port) and hit the 'upload' button to load your code onto the Arduino.

Now we're ready to see if we can magically (or through code) detect the 'Hello, world!' string we're sending from Processing. Processing

Our task now is to find a way to listen in on what our Arduino sketch is sending. Luckily, Processing comes with a Serial library designed for just this kind of thing! If you don't have a version of Processing, make sure you go to and download the latest version for your operating system. Once Processing is installed, open it up. You should see something like this:

Looks a lot like Arduino, huh? The Arduino software was actually based in part off of Processing - that's the beauty of open-source projects. Once we have an open sketch, our first step is to import the Serial library. Go to Sketch->Import Library->Serial, as shown below:

You should now see a line like import processing.serial.*; at the top of your sketch. Magic! Underneath our import statement we need to declare some global variables. All this means is that these variables can used anywhere in our sketch. Add these two lines beneath the import statement:

In order to listen to any serial communication we have to get a Serial object (we call it myPort but you can it whatever you like), which lets us listen in on a serial port on our computer for any incoming data. We also need a variable to recieve the actual data coming in. In this case, since we're sending a String (the sequence of characters 'Hello, World!') from Arduino, we want to receive a String in Processing.Just like Arduino has setup() and loop(), Processing has setup() and draw() (instead of loop).

For our setup() method in Processing, we're going to find the serial port our Arduino is connected to and set up our Serial object to listen to that port.

Remember how we set Serial.begin(9600) in Arduino? Well, if we don't want that gobbledy-gook I was talking about, we had better put 9600 as that last argument in our Serial object in Processing as well. This way Arduino and Processing are communicating at the same rate. Happy times!

In our draw() loop, we're going to listen in on our Serial port and we get something, stick that something in our val variable and print it to the console (that black area at the bottom of your Processing sketch).

Ta-Da! If you hit the 'run' button (and your Arduino is plugged in with the code on the previous page loaded up), you should see a little window pop-up, and after a sec you should see `Hello, World!' appear in the Processing console. Over and over. Like this:

Excellent! We've now conquered how to send data from Arduino to Processing. Our next step is figure out how go the opposite way - sending data from Processing to Arduino.

From Processing..

So we've sent data from Arduino to Processing, but what if we want to send data the other way - from Processing to Arduino? Piece of cake!

Let's start with the Processing side of things. It starts out much like our last sketch: we import the Serial library and declare a global Serial object variable for our port up top, and in our setup() method we find our port and initialize Serial communication on that port with our Serial variable at 9600 baud. We're also going to use the size() command, to give us a little window to click in, which will trigger our sketch to send something over the Serial port to Arduino.

In our draw() loop, we send whatever we want over the serial port by using the write method from the Processing Serial library. For this sketch, we will send a '1' whenever we click our mouse in the Processing window. We'll also print it out on the console, just to see that we're actually sending something. If we aren't clicking we'll send a '0' instead.

This is what your code should look like at this point:

If you run this code, you should see a bunch of 1's appear in the console area whenever you click your mouse in the window. Neat! But how do we look for these 1's from Arduino? And what can we do with them? Arduino

Ok! On this page we're going to look for those 1's coming in from Processing, and, if we see them, we're going to turn on an LED on pin 13 (on some Arduinos, like the Uno, pin 13 is the on-board LED, so you don't need an external LED to see this work).

At the top of our Arduino sketch, we need two global variables - one for holding the data coming from Processing, and another to tell Arduino which pin our LED is hooked up to.

Next, in our setup() method, we'll set the LED pin to an output, since we're powering an LED, and we'll start Serial communication at 9600 baud.

Finally, in the loop() method, we'll look at the incoming serial data. If we see a '1', we set the LED to HIGH (or on), and if we don't (e.g. we see a '0' instead), we turn the LED off. At the end of the loop, we put in a small delay to help the Arduino keep up with the serial stream.

This is what your code should look like when you're done:

Voila! If we load up this code onto our Arduino, and run the Processing sketch from the previous page, you should be able to turn on an LED attached to pin 13 of your Arduino, simply by clicking within the Processing canvas.

Shaking Hands (Part 1)

So far we've shown that Arduino and Processing can communicate via serial when one is talking and the other is listening. Can we make a link that allows data to flow both ways, so that Arduino and Processing are both sending and receiving data? You bet! In the biz we call this a serial 'handshake', since both sides have to agree when to send and receive data.

On this page and the next, we're going to combine our two previous examples in such a way that Processing can both receive 'Hello, world!' from Arduino AND send a 1 back to Arduino to toggle an LED. Of course, this also means that Arduino has to be able to send 'Hello, world!' while listening for a 1 from Processing. Whew!

Let's start with the Arduino side of things. In order for this to run smoothly, both sides have to know what to listen for and what the other side is expecting to hear. We also want to minimize traffic over the serial port so we get more timely responses.

Just like in our Serial read example, we need a variable for our incoming data and a variable for the LED pin we want to light up:

Since we're trying to be efficient, we're going to change our code so that we only listen for 1's, and each time we hear a '1' we toggle the LED on or off. To do this we added a boolean (true or false) variable for the HIGH or LOW state of our LED. This means we don't have to constantly send a 1 or 0 from Processing, which frees up our serial port quite a bit.

Our setup() method looks mostly the same, with the addition of an establishContact() function which we'll get to later - for now just type it in.

In our loop function, we've just combined and slimmed down the code from our two earlier sketches. Most importantly, we've changed our LED code to toggle based on our new boolean value. The '!' means every time we see a one, we set the boolean to the opposite of what it was before (so LOW becomes HIGH or vice-versa). We also put our 'Hello, world!' in an else statement, so that we're only sending it when we haven't seen a '1' come in.

Now we get to that establishContact() function we put in our setup() method. This function just sends out a string (the same one we'll need to look for in Processing) to see if it hears anything back - indicating that Processing is ready to receive data. It's like saying 'Marco' over and over until you hear a 'Polo' back from somewhere.

Your Arduino code should look like this:

That's it for the Arduino side, now on to Processing!

Shaking Hands (Part 2)

For the Processing side of things, we've got to make a few changes. We're going to make use of the serialEvent() method, which gets called every time we see a specific character in the serial buffer, which acts as our delimiter - basically it tells Processing that we're done with a specific 'chunk' of data - in our case, one 'Hello, world!'.

Arduino Serial Read

The beginning of our sketch is the same except for a new firstContact boolean, which let's us know when we've made a connection to Arduino.

Our setup() function is the same as it was for our serial write program, except we added the myPort.bufferUntil('n'); line. This let's us store the incoming data into a buffer, until we see a specific character we're looking for. In this case, it's a carriage return (n) because we sent a Serial.println from Arduino. The 'ln' at the end means the String is terminated with a carriage return, so we know that'll be the last thing we see.

Because we're continuously sending data, our serialEvent() method now acts as our new draw() loop, so we can leave it empty:

Now for the big one: serialEvent(). Each time we see a carriage return this method gets called. We need to do a few things each time to keep things running smoothly:

  • read the incoming data
  • see if there's actually anything in it (i.e. it's not empty or 'null')
  • trim whitespace and other unimportant stuff
  • if it's our first time hearing the right thing, change our firstContact boolean and let Arduino know we're ready for more data
  • if it's not our first run, print the data to the console and send back any valid mouse clicks (as 1's) we got in our window
  • finally, tell Arduino we're ready for more data

That's a lot of steps, but luckily for us Processing has functions that make most of these tasks pretty easy. Let's take a look at how it all breaks down:

Oof. That's a lot to chew on, but if you read carefully line by line (especially the comments), it'll start to make sense. If you've got your Arduino code finished and loaded onto your board, try running this sketch. You should see 'Hello, world!' coming in on the console, and when you click in the Processing window, you should see the LED on pin 13 turn on and off. Success! You are now a serial handshake expert.

Tips and Tricks

Arduino Serial Monitor

In developing your own projects with Arduino and Processing, there are a few 'gotchas' that are helpful to keep in mind in case you get stuck.

Arduino Serialout

  • make sure your baud rates match
  • make sure you're reading off the right port in Processing - there's a Serial.list() command that will show you all the available ports you can connect to.
  • if you're using the serialEvent() method, make sure to include the port.bufferUntil() function in your setup() method.
  • also, make sure that whatever character you're buffering until (e.g., 'n') is a character that you're actually sending from Arduino.
  • If you want to send over a number of sensor values, it's a good idea to count how many bytes you're expecting so you know how to properly parse out the sensor data. (the example (shown below) that comes with Arduino gives a great example of this:
This is the example to select for some good sensor parsing code

Resources and Going Further

Arduino Serial Plotter

Now that you know how to send data from Arduino to Processing and back again (even simultaneously!), you're ready for some seriously cool projects. By hooking together Arduino and Processing, you can do things like visualize sensor data in real-time, or make a glove with flex sensors in the fingers that makes penguins appear on the screen, or a command console from Processing that controls a giant array of LEDs.

Here are a few useful links that you may find useful going forward: