• Arduino Usb Host Library

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. Libraries are great places, and not yet illegal in the United States!

Send Serial Data to Host Using Arduino Hardware: In this model, the Arduino hardware sends data to your computer over the serial port 0 (USB port) of the Arduino hardware. This model is configured to run in Normal mode. In this mode, the model is deployed on the Arduino hardware.

I am using an Arduino-compatible board with USB host shield to send and receive serial data throught its USB port. Note for any beginners out there, this nice video explains how to do Arduino ser. Usb-serial-for-android is my open source library written for exactly this need. It supports FTDI and CDC-ACM usb serial devices using Android's USB host support; no root or ADK necessary. It can talk most Arduinos. The project is still in its early days, but the basic support has worked well enough for several projects.

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: 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, where you can use dits and dahs to send messages by 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. SneakersNow 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 answer200 GB.

1024 = 204800 MB204800 MB. 1024 = 209715200 KB209715200 KB. 1024 = 00 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 answer200 GB. 1000 = 200000 MB200000 MB. 1000 = 200000000 KBHow much less storage do you get thanks to the marketing guy who came up with this trick?Highlight the text below for the answerAbout 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.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). 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. Serial.println( 'Hello world!' ); // prints hello with ending line breakThis 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 answer12 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 answerThis 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.

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.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.So.click it! WindowsMac OS XLinuxNGArduino does not reset.Arduino does not reset.Arduino does not reset.DiecimilaArduino resets, starts the sketch a few seconds laterArduino resets, starts the sketch a few seconds laterArduino resets, starts the sketch a few seconds laterIn 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 laterOtherwise, 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! Baud rate match up!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!

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.

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 answerSimply 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 answerIt's lit, not blinking. Try waving the Arduino around in a dark room, what do you see?Highlight the text below for the answerThere are little dotted light trails. What's going on here? Hint: Remember?Highlight the text below for the answerThe data is being transmitted so fast, that we can't see the TX LED blinking.it'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. Println(a + b);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 printlnNote 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!. (this one's pretty nice, just ignore the cout stuff which is C's way of printing out values). 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 answerSerial.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 printlnNow 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.

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 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 answerThere are 8 bits in 1 byte so 2 bytes is 16 bitsTo 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 2 16 - 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. Drivemb = 1024. drivegb;If you look at this line, what's happening here is that the Arduino looks up the value of the variable drivegb to get 100.

Then we multiply 100 by 1024 to get 102400 and put that in the drivemb box. Except the way that the Arduino software does this is that it creates a temporary variable the same size as drivegb to store that calculation result before it sticks it into drivemb.

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. 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 2 16 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.Unsigned variables can only store positive numbers.By default, variables are signed. Why Types?OK so you're probably wondering: 'This is such a pain, why bother with different size types?

Arduino Usb Host Library

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. 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. Technicolor router keygen for windows xp. 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.