Month: January 2020

Made your way through all the previous sections? Well done! You are well on your way towards programming for the robotics team, not to mention being able to program an Arduino for yourself and any side projects you want to tackle!

In this section we are going to use the temperature sensor from the kit, and more importantly than that we are going to learn about something called the serial monitor.

You already understand that your Chromebook is sending your code into your Arduino board over the USB cable, but that is not all that the USB connection is good for. The Arduino can actually send messages and data back to your Chromebook over the USB cable as well. This capability is what we are going to leverage to get the temperature readings from the sensor back to your Chromebook. This way we don’t have to hook up an LCD screen to the Arduino just to get some readings from a sensor.

Lets start with the usual steps, download the pages from chapter 9 of the starter kit tutorial here and load up the code below:

Code:

#include "DHT.h"

#define DHTPIN 2     // what pin we're connected to

#define DHTTYPE DHT11   // DHT 11 (there are other types we could be using, such as DHT22)

// Initialize DHT sensor for normal 16mhz Arduino
DHT dht(DHTPIN, DHTTYPE);

void setup() {
  Serial.begin(9600); 
  Serial.println("DHTxx test!");
 
  dht.begin();
}

void loop() {
  // Wait a few seconds between measurements.
  delay(2000);

  // Reading temperature or humidity takes about 250 milliseconds!
  // Sensor readings may also be up to 2 seconds 'old' (its a very slow sensor)
  float h = dht.readHumidity();
  // Read temperature as Celsius
  float t = dht.readTemperature();
  // Read temperature as Fahrenheit
  float f = dht.readTemperature(true);
  
  // Check if any reads failed and exit early (to try again).
  if (isnan(h) || isnan(t) || isnan(f)) {
    Serial.println("Failed to read from DHT sensor!");
    return;
  }

  // Compute heat index
  // Must send in temp in Fahrenheit!
  float hi = dht.computeHeatIndex(f, h);

  Serial.print("Humidity: "); 
  Serial.print(h);
  Serial.print(" %\t");
  Serial.print("Temperature: "); 
  Serial.print(t);
  Serial.print(" *C ");
  Serial.print(f);
  Serial.print(" *F\t");
  Serial.print("Heat index: ");
  Serial.print(hi);
  Serial.println(" *F");
}

Like with the passive buzzer, you will notice at the top of the code that we are using a library to help us use the sensor. Thanks to this library we do not have to read and interpret the raw bits of data the sensor puts out. This makes things easier for us and keeps our code neat and tidy, and easier to understand.

Opening the serial monitor is slightly different in codebender than it is for the IDE used in the tutorial, but its still very easy. Click on the “Serial Monitor” button in the upper right-hand corner of the codebender page and then click on “Connect” in the window that opens up in the lower half of the page.

Once successfully connected the serial monitor will start displaying the messages that your Arduino code is sending back over the USB cable, as shown above.

Note that in our setup function we have to initialize the usage of the serial monitor with “Serial.begin(9600);” This sets up the serial connection to send data back to the Chromebook.

Try playing around with the code to change the output coming back to the serial monitor. Try putting the temperature first, and then the humidity. Try removing the heat index portion (what is that anyways?)

Notice that in the serial monitor there is a box where you can type and send a message back to the Arduino. Yes, this is a two-way communication street. It is possible to do things such as turning an LED on and off by sending a message over the serial interface, and sometimes this is easier than wiring in a button.

The serial monitor is very handy for sending back complex data that is difficult for the Arduino to display without a screen, and also handy for debugging code to find problem spots.

Not every type of code and chip you will ever use will communicate via a serial interface, but most will have some kind of text output that will be similar to this which you can use to read and debug data.

When you are done with this section we can make our way to the next part, in which we get to use one of my favorite components: the servo motor.

Ready to start hooking stuff from the kit up to your board and making them do things? Great!

Lets learn how to control an LED that is not built into our board. We will make one of the LEDs in our starter kit light up along with the LED on our board:

To do this we are going to need five items out of our Arduino starter kit:
1) The breadboard
2) An LED (Pick any color you want, make sure it is an LED with only two legs/wires coming out of it)
3) A 1k resistor
4/5) Two wires (preferably one red and one black)

We need to fill in some background information about what these components are in order to understand how to use them. Right about now is a good time to bring up something about the Arduino starter kit, especially if it was handed directly to you from one of us coaches or mentors: The starter kit comes with a complete 176 page tutorial that covers how to use every component that came in your kit. Usually this tutorial document comes on a CD-ROM, if I gave you the kit directly chances are I already took the CD out of the kit. Its not like there is a CD-ROM drive in your Chromebook anyways, right?

So, am I going to re-write the entire tutorial that came with the kit here on this website? Of course not. I had to write the first part of this series because the first three chapters of the tutorial give you instructions on how to use an Arduino with a Windows or Mac computer. We needed instructions for programming Arduino via your Chromebook, but now that you are getting to the point where you can write and upload code and get it from your Chromebook onto your board pretty soon here we are going to start referring you to the tutorial that came with the kit (to save my fingers from getting tired of typing!)

The tutorial that came with the kit does a nice job of talking about the parts we need to use for this lesson, so I’m going to copy and paste that here. So far I have been modifying their lessons slightly, and in the case of running this external LED I am doing the same thing, so don’t worry about the first part of the first page talking about a slightly different list of components. Please read through the pages to get an initial understanding of the components we are using, and then come back here to this page to continue the lesson after reading through it:

Ok, have you downloaded and read the except from the starter kit’s tutorial? Then lets move on.

The last part of the document was talking about resistors. Resistors serve a very important purpose in electronics, but other than using them for our Arduino lessons you won’t often need to mess with them much once you start programming an FRC Robot. You won’t be using many LEDs either, for that matter.

Indeed, if you look through your box of parts in your starter kit there are many things in it that you will probably never use on a competition robot (such as the temperature sensor). Even though not all of these components have a direct use in building an FRC robot, I still want you to learn about most of them because what we are trying to do here is to lay the groundwork and base knowledge of programming a board to use various components.

Just because you may never use a temperature sensor on on a competition robot doesn’t mean that knowledge won’t be useful down the road. You may eventually need to use a similar sensor, perhaps a color sensor, and many of these thing work in a similar fashion so just keep that in mind as you continue through these lessons.

Anyways, back to resistors, they send about a gazillion of those tiny things in your starter kit. Depending on what year it is and what the situation is, there are about three possibilities of the status of the resistors in your particular kit:

1. It might be a brand new kit AND the packs of resistors are labeled with their values:

2. It might also be that you have a brand new kit, but the packs of resistors are NOT labeled:

3. Worse than that, you might just get a used kit in which the resistors are laying loose all over the box….

Now, they do send you this nice color chart in the kit (hopefully its still in there if you have a used kit) which can help you determine the values of the resistors:

But even still… we are trying to focus on the programming aspect and getting you up to speed so you can work on the actual robot. We already said you won’t have to mess with resistors much on the actual robot, so basically if you don’t get a nice set of resistors that are already labeled for you and ready to go, feel free to reach out to your coach or mentor and see if they can help you out there. If you feel like learning enough about resistors to figure it out on your own, go for it, but this is one area where we don’t need to get too terribly deep into it to get you the knowledge you need to move forward.

If you are going to be turning in your kit at the end of the season please keep the organization of the resistors in mind for the next person who will need to use the kit. Everything else in the kit is fairly distinctive but all the resistors look the same so try not to get them all mixed up and disorganized.

All you need right now is one resistor that is at least 220 ohms, but preferably 1k.

Now, on to hooking up these parts.

The short explanation is that to use an LED, you must also use a resistor to limit the electrical current to avoid burning out the LED. We don’t want to be burning up our parts! The tutorial wants you to hook the LED up according to the diagram and schematics below. This is fine if you want to follow that to start with, but what they are having you do is hook the LED up to direct power off the board. Thats ok to start with but right afterwards we are going to make a small tweak to their layout.

A description from page 41 of the stock tutorial:

The above is fine, but assuming your Arduino is still running the same Blink sketch from the previous lesson I’d rather have you wire up your LED to pin 13 (and you can use the ground (GND) pin right next to it, all the GND pins on the board are the same) like this:

Pin 13 is wired to BOTH the built-in LED on the board and the pin slot #13 on the board itself, so if you wire up your LED to it you should see the built-in LED and your breadboard LED flash together like this:

Self-guided Experiment:

Something to try on your own now: What would you need to do to your code if you wanted to power the breadboard LED from pin 12 instead of pin 13? Try it now.

Hint: You only need to change one thing on line # 10…

All good so far with putting an LED on your breadboard and turning it on and off with your code? If so, you are ready to move on to the next section. If you are having difficulties, please chat with your coach or mentor to get over any humps before moving on.

In the previous section of the series we got our programming tools squared away and got our first piece of code uploaded to our Arduino board. We didn’t write this code ourselves, and soon you will find out just how typical it is to start off with a sample or snippet from the internet. Very few people have enough knowledge memorized to simply open up a blank code editor and start spewing out flawless code without any help or external reference.

Lets take a closer look at the two dozen or so lines of sample code we uploaded to our board that caused the board’s built-in LED to ‘Blink’:

The green text is what we call “comments”. Comments are not code, rather, they are bits of pieces of information we leave like breadcrumbs for ourselves and others to help describe what a portion of code is doing.

There are two kinds of comments;
A single-line comment begins with two slashes like this: //
A multi-line comment is wrapped with /* and */
The /* is the beginning of the multi-line comment, and the */ is the end.

The // and /**/ tell the compiler to ignore this piece of text because it is not code, its just information we write to ourselves or for other people who will have to read and understand the code later.

So other than the comments, the only *real* code in the whole 26 line file is on lines 10, 13-17, and 20-26.

On Line 10 we are declaring a integer-type variable and setting it to a value of 13.
13 is the number of the pin on our Arduino board that also happens to be connected to the built-in LED. The Arduino Uno has many pins that we can use to connect to more LEDs, motors, sensors, buttons etc to make the Arduino do more stuff.

Line 13 is the start of a critical portion of any Arduino sketch (a sketch is what they call a chunk of code written for Arduino). This line begins the setup function, which is a chunk of code that runs one time when the Arduino board is first powered up. The only code in our setup function is a single pinMode command that tells the board we are going to use pin number 13 as an output (to drive the LED).

From there we get to Line 20, which starts the other critical portion of any Arduino sketch called the loop. The loop is pretty much what it sounds like, a set of commands that the Arduino board will repeat over and over again (forever, or until it is unplugged).

There are only four lines that make up whats happening in our loop, two output writes and two delays. We write a HIGH output to the LED pin, we wait for one second (1000 milliseconds), then we write LOW to the LED pin, and wait another second. This repeats for as long as your board is plugged into power.

Lets change this up a little. In the two lines of the loop that say “delay(1000);” go ahead and change the numbers (the milliseconds of delay) to something else, such as “delay(100);”. After making this change, use the ‘Run on Arduino’ button in the upper left to send the changed code to the board.

The LED is now blinking 10 times faster, because we have shortened the delays from one full second to one-tenth of a second.

Now change the delays to be “delay(20);”
Notice the LED blinks quite fast now.

How about “delay(10);” ?
Now the LED blinks so fast your eye can hardly detect the rapid flickering. The LED is still turning on and off, but its doing it so quickly that to us the LED is more or less just “On”.

This highlights an important concept for you to understand. The loop function happens fast. Very, very fast. Your Arduino Uno can execute roughly 16 million instructions per second. Without putting a delay in between the commands where we turn the LED ON and OFF, we would never stand a chance of seeing the program work with our eyes. Its simply happening way too fast for us to see.

Go ahead and play with some other values for the delay commands. What happens when they are not the same number of milliseconds?

Its handy that our board has a light built-in so that we could play with some code without having to hook anything else up to our board, but we want to learn how to control other things connected to our board. Eventually we need to be able to program things to control motors, sensors, react to buttons and joysticks, etc. So what are we waiting for? Lets move on to the next lesson and look at how we can control our own LED light off the board.

As of this writing, the vast majority of Arduino tutorials assume you have a windows or mac computer running the IDE provided by Arduino itself. The students I work with are issued Chromebooks by the school, so the first thing we need to address is how to work with Arduino code in a Chromebook and how to program our Arduino board from the same.

codebender to the rescue!

There is more than one way to program an Arduino board from a Chromebook. The tool I have chosen for our purposes is codebender, an online IDE that works with Chromebooks (and almost any other device that can browse the internet). I’m going with codebender because they have a special education version that makes it even easier to get the students the tools they need without any installation process or complicated setup. Many props to them for providing this tool for our use (I mean, its not free, but I’m still glad they provide it!)

If you are not a student you can use the regular version of codebender. There is a free trial you can get started with to see if you like it, if you don’t feel free to google around for other Arduino IDE tools that work on ChromeOS. The tutorials I’m writing should work with just about any IDE you can find.

STUDENTS: To access the codebender tool from your Chromebook you will need a special link we will provide either in-person or via email/Discord. Make sure you have received this link and are able to open the codebender tool before proceeding. Contact a coach or mentor if you have any issues or still need to get the link.

If the link is working for you (or if you are using the regular version of codebender) you should find yourself on a page that looks like the screenshot above. Basically a blank code window ready to use to write code for our Arduino board.

The first thing you will want to do is install the codebender plugin for Chrome. This is what allows the online code editor to detect and push code to your Arduino board.

If you are opening the tool for the first time, there should be a grey bar at the top with a link to click on that will take you to the plugin page. At this time I don’t know for certain if there will be any blocks or issues with that on a student device, talk to your coach or mentor if you run into any issues at this step.

The next thing you will want to do is set the correct board in the upper-left menu.
Almost every Arduino starter kit comes with an Arduino Uno, so most likely this is what you will need to select here:

If you are using any other board (such as a Nano), choose the board that matches whatever you are using.

Next we’re going to load up a little bit of sample code and see if we can get it onto our board. We’ll dive into exactly what this code does in a little bit, but for now lets just see if we can get the code from our Chrombook into the Arduino board.

Open the hamburger menu in the upper-right-hand corner of the editor, hover over “Load Example” and select the “Blink” menu option within. The sample code for the “Blink” sketch should get loaded into the editor window:

Now, in the upper left we have two green buttons that do two important things for us.

“Verify Code”:

This button is used to compile your code and check it for syntax errors. You can click on this button and you should see a message in the grey bar to the right that says “Verification Successful”

And the other button, “Run on Arduino” will actually send your code to your Arduino board.

There is more than one way to do this, but typically we will be programming our boards over a USB cable. Make sure your Arduino board is connected to your Chromebook’s USB port and try to send the “Blink” code to your Arduino now.

If this works, the message in the grey bar at the top will say “Upload successful!” and the orange or yellow LED light on your Arduino Uno board will begin to blink slowly:

If this is working then our programming tools are set and you are ready to move on to the Arduino code tutorials in the next sections. If you are stuck with some kind of error and the code won’t upload to your board, you can reach out to a couch or mentor for help and/or try googling the issue a bit and see if you can find a solution (especially if its going to be a while before a coach or mentor can check out your setup.)

In the next section we will take a closer look at the “Blink” sample code to learn more about what it does and how it works.

Welcome! There are two reasons why you might have ended up on his page. Either you got here from Google (which means my website is doing amazingly well), OR (much more likely) you are a student on the robotics team who got sent here to get started with learning some programming.

That second scenario is going to be the assumption for the following pages in these tutorials. If you are NOT a student who was sent here by direct reference, the tutorials may still be helpful but you should know that a lot of the core material simply comes from the tutorial PDF that comes with almost any Arduino Starter Kit found on Amazon.

The main reasons I’m putting this series together are
1) The students I’m working with in robotics are using Chromebooks, and the tutorial that comes in the starter kits only cover windows/mac/linux.
2) The tutorial in the starter kit is extensive. I want to focus on the portions that are pertinent to robotics and skip over some of the unrelated components in the kit. Later in the series I also want to expand on some components a little further than the base tutorial does.

So what are we trying to accomplish here with our Arduinos? Competition FRC robots are not run by Arduino, so how does learning about these little microchips help us?

Well, you’re likely here because you said you are interested in programming for the robotics team, but you are extremely new to it. Nothing wrong with that. Everyone starts somewhere, but diving straight into competition robot programming from scratch is like starting out learning to swim by putting on deep sea scuba gear.

Programming can often be difficult and discouraging. FIRST Robotics wants their program, coaches, and mentors to encourage and inspire students towards science and technology, not put them off from it. I agree with that goal 100%, and my opinion is that the best way for younger/newer students to start learning about programming related to robotics is with small, bite size examples they can do hands-on at their own pace (with coach and mentor assistance and guidance, of course).

The design and build period for the robotics competition is short and hectic. There is a lot going on and, if your team is going the full-on code route, there is a heck of a lot of code to write. The programming division of the team will need to bring together code to control half a dozen or more motors and components to carry out the game tasks. Without working code, the robot can’t play the game. Without good code, the robot probably can’t play the game well and competitively. Worse yet, if the newest programming students have an overly difficult and stressful time trying to dive directly into advanced programming they may become too discouraged to stick with it.

With that in mind, this series intends to get new students rolling with a customized guide through a standard Arduino starter kit. Arduino programming is very similar to the kind of programming done for a roboRIO on an FRC bot. Once you are comfortable scratching out some code for an Arduino board, you will be in a great spot to make the jump to programming for a roboRIO, and the code you will see the older students making for the roboRIO will start to make more sense.

This is still going to be something of a crash-course, we are going to glaze over some details and nuances here and there for the sake of expediency, and also because the internet is already full of great info and tutorials you can google to your heart’s content (no need for me to recreate the wheel). Please don’t limit yourself only to my tutorials, there is a whole world of great resources out there on the internet.

If you are ready to get started, lets move on to the next post in the series to get familiar with our Arduino kit and learn how we program it from our Chromebooks.