Google Earth Pro N/A serial key or number

Important: To use Google Earth Pro and its features, you must have the following versions of the app:

• Version or newer is required to use Google Earth Pro
• Version or newer is required to access Google Street View within Google Earth Pro

Google Earth Pro functions with most recent versions of the Ubuntu and Fedora Linux distributions. Google Earth Pro may run on other popular distributions as well, but due to the wide variety of Linux platforms available, this is not guaranteed.

1. Download Google Earth Pro.
2. Double-click the file and follow the installation process.
3. To open Google Earth Pro, click Start  Programs  Google Earth Pro. Then, click Google Earth Pro.

1. Download Google Earth Pro.
2. Open "manicapital.com".
3. Open the "Install Google Earth manicapital.com" file and follow the installation process.
4. To open Google Earth Pro, open your Applications folder and double-click Google Earth Pro.

Note: During the installation process, Mac OS X will ask for an administrator password. This information is never shared with Google.

Before attempting any of the instructions below:

MSI or .dll error

1. To uninstall your version of Google Earth Pro, click Control Panel Uninstall a program.
   Note: in some versions of Windows, you need to click Control Panel Add or Remove Programs.
2. Upgrade to the latest version from the Google Earth Pro download link.

If you're having trouble connecting to Google Earth Pro and your machine has a software firewall, Google Earth Pro might not be able to access the internet. Examples of common anti-virus software firewalls include:

• McAfee Personal Firewall Plus (also in McAfee Internet Security Suite)
• ZoneAlarm
• Norton Personal Firewall

To help fix firewall issues in your anti-virus software preferences, verify:

• manicapital.com is not blocked (Windows only)
• Access to 'port 80' is available for non-browser applications

Note

Serial communications are also a handy tool for debugging. You can send debug messages from Arduino to the computer and display them on your computer screen.

Serial hardware sends and receives data as electrical pulses that represent sequential bits. The zeros and ones that carry the information that makes up a byte can be represented in various ways. The scheme used by Arduino is 0 volts to represent a bit value of 0, and 5 volts (or volts) to represent a bit value of 1.

Boards including the Uno, Duemilanove, Diecimila, Nano, and Mega have a chip to convert the hardware serial port on the Arduino chip to Universal Serial Bus (USB) for connection to the hardware serial port. Other boards, such as the Mini, Pro, Pro Mini, Boarduino, Sanguino, and Modern Device Bare Bones Board, do not have USB support and require an adapter for connecting to your computer that converts TTL to USB. See manicapital.com for more details on these boards.

Some popular USB adapters include:

Some serial devices use the RS standard for serial connection. These usually have a nine-pin connector, and an adapter is required to use them with the Arduino. RS is an old and venerated communications protocol that uses voltage levels not compatible with Arduino digital pins.

You can buy Arduino boards that are built for RS signal levels, such as the Freeduino Serial v (manicapital.com).

RS adapters that connect RS signals to Arduino 5V (or V) pins include the following:

A standard Arduino has a single hardware serial port, but serial communication is also possible using software libraries to emulate additional ports (communication channels) to provide connectivity to more than one device. Software serial requires a lot of help from the Arduino controller to send and receive data, so it’s not as fast or efficient as hardware serial.

The Arduino Mega has four hardware serial ports that can communicate with up to four different serial devices. Only one of these has a USB adapter built in (you could wire a USB-TTL adapter to any of the other serial ports). Table  shows the port names and pins used for all of the Mega serial ports.

You will usually use the built-in Arduino serial library to communicate with the hardware serial ports. Serial libraries simplify the use of the serial ports by insulating you from hardware complexities.

Sometimes you need more serial ports than the number of hardware serial ports available. If this is the case, you can use an additional library that uses software to emulate serial hardware. Recipes and show how to use a software serial library to communicate with multiple devices.

The hardware or software serial libraries handle sending and receiving information. This information often consists of groups of variables that need to be sent together. For the information to be interpreted correctly, the receiving side needs to recognize where each message begins and ends. Meaningful serial communication, or any kind of machine-to-machine communication, can only be achieved if the sending and receiving sides fully agree how information is organized in the message. The formal organization of information in a message and the range of appropriate responses to requests is called acommunications protocol.

Messages can contain one or more special characters that identify the start of the message—this is called the header. One or more characters can also be used to identify the end of a message—this is called the footer. The recipes in this chapter show examples of messages in which the values that make up the body of a message can be sent in either text or binary format.

Sending and receiving messages in text format involves sending commands and numeric values as human-readable letters and words. Numbers are sent as the string of digits that represent the value. For example, if the value is , the characters 1, 2, 3, and 4 are sent as individual characters.

Binary messages comprise the bytes that the computer uses to represent values. Binary data is usually more efficient (requiring fewer bytes to be sent), but the data is not as human-readable as text, which makes it more difficult to debug. For example, Arduino represents as the bytes 4 and (4 * + = ). If the device you are connecting to sends or receives only binary data, that is what you will have to use, but if you have the choice, text messages are easier to implement and debug.

There are many ways to approach software problems, and some of the recipes in this chapter show two or three different ways to achieve a similar result. The differences (e.g., sending text instead of raw binary data) may offer a different balance between simplicity and efficiency. Where choices are offered, pick the solution that you find easiest to understand and adapt—this will probably be the first solution covered. Alternatives may be a little more efficient, or they may be more appropriate for a specific protocol that you want to connect to, but the “right way” is the one you find easiest to get working in your project.

 Sending Debug Information from Arduino to Your Computer

You want to send text and data to be displayed on your PC or Mac using the Arduino IDE or the serial terminal program of your choice.

This sketch prints sequential numbers on the Serial Monitor:

Connect Arduino to your computer just as you did in Chapter 1 and upload this sketch. Click the Serial Monitor icon in the IDE and you should see the output displayed as follows:

To display text and numbers from your sketch on a PC or Mac via a serial link, put the statement in , and then use statements to print the text and values you want to see.

The Arduino Serial Monitor function can display serial data sent from Arduino. To start the Serial Monitor, click the Serial Monitor toolbar icon as shown in Figure  A new window will open for displaying output from Arduino.

Your sketch must call the function before it can use serial input or output. The function takes a single parameter: the desired communication speed. You must use the same speed for the sending side and the receiving side, or you will see gobbledygook (or nothing at all) on the screen. This example and most of the others in this book use a speed of 9, baud (baud is a measure of the number of bits transmitted per second). The 9, baud rate is approximately 1, characters per second. You can send at lower or higher rates (the range is to ,), but make sure both sides use the same speed. The Serial Monitor sets the speed using the baud rate drop down (at the bottom right of the Serial Monitor window in Figure ). If your output looks something like this:

you should check that the selected baud rate on your computer matches the rate set by in your sketch.

You can display text using the function. Strings (text within double quotes) will be printed as is (but without the quotes). For example, the following code:

prints this:

The values (numbers) that you print depend on the type of variable; see Recipe  for more about this. But for now, printing an integer will print its numeric value, so if the variable is , the following code:

will print this:

In the example sketch, the number printed will be when the loop starts and will increase by one each time through the loop. The at the end of causes the next print statement to start on a new line.

That should get you started printing text and the decimal value of integers. See Recipe  for more detail on print formatting options.

You may want to consider a third-party terminal program that has more features than Serial Monitor. Displaying data in text or binary format (or both), displaying control characters, and logging to a file are just a few of the additional capabilities available from the many third-party terminal programs. Here are some that have been recommended by Arduino users:

In addition, an article in the Arduino wiki explains how to configure Linux to communicate with Arduino using TTY (see manicapital.com).

You can use a liquid crystal display as a serial output device, although it will be very limited in functionality. Check the documentation to see how your display handles carriage returns, as some displays may not automatically advance to a new line after statements.

The Arduino LiquidCrystal library for text LCDs uses underlying print functionality similar to the Serial library, so you can use many of the suggestions covered in this chapter with that library (see Chapter 11).

 Sending Formatted Text and Numeric Data from Arduino

You want to send serial data from Arduino displayed as text, decimal values, hexadecimal, or binary.

You can print data to the serial port in many different formats; here is a sketch that demonstrates all the format options:

The output (condensed here onto a few lines) is as follows:

Printing a text string is simple: sends the text string “hello world” to a device at the other end of the serial port. If you want your output to print a new line after the output, use instead of .

Printing numeric values can be more complicated. The way that byte and integer values are printed depends on the type of variable and an optional formatting parameter. The Arduino language is very easygoing about how you can refer to the value of different data types (see Recipe  for more on data types). But this flexibility can be confusing, because even when the numeric values are similar, the compiler considers them to be separate types with different behaviors. For example, printing a will not necessarily produce the same output as printing an of the same value.

Here are some specific examples; all of them create variables that have similar values:

Table  shows what you will see when you print variables using Arduino routines.

The sketch in this recipe uses a separate line of source code for each print statement. This can make complex print statements bulky. For example, to print the following line:

you’d typically have to code it like this:

That’s a lot of code lines for a single line of output. You could combine them like this:

Or you could use the insertion-style capability of the compiler used by Arduino to format your print statements. You can take advantage of some advanced C++ capabilities (streaming insertion syntax and templates) that you can use if you declare a streaming template in your sketch. This is most easily achieved by including the Streaming library developed by Mikal Hart. You can read more about this library and download the code from Mikal’s website.

If you use the Streaming library, the following gives the same output as the lines shown earlier:

 Receiving Serial Data in Arduino

You want to receive data on Arduino from a computer or another serial device; for example, to have Arduino react to commands or data sent from your computer.

It’s easy to receive 8-bit values (chars and bytes), because the functions use 8-bit values. This sketch receives a digit (single characters 0 through 9) and blinks the LED on pin 13 at a rate proportional to the received digit value:

Upload the sketch and send messages using the Serial Monitor. Open the Serial Monitor by clicking the Monitor icon (see Recipe ) and type a digit in the text box at the top of the Serial Monitor window. Clicking the Send button will send the character typed into the text box; you should see the blink rate change.

Converting the received ASCII characters to numeric values may not be obvious if you are not familiar with the way ASCII represents characters. The following converts the character to its numeric value:

This is done by subtracting 48, because 48 is the ASCII value of the digit 0. For example, if is representing the character 1, its ASCII value is The expression is the same as . This equals 1, which is the numeric value of the character 1.

In other words, the expression is the same as ; this converts the ASCII value of the variable to a numeric value.

To get a clearer idea of the relationship between the ASCII values of characters representing the digits 0 through 9 and their actual numeric values, see the ASCII table in Appendix G.

Receiving numbers with more than one digit involves accumulating characters until a character that is not a valid digit is detected. The following code uses the same and functions as those shown earlier, but it gets digits until the newline character is received. It uses the accumulated value to set the blink rate.

Change the code that the code follows. Enter a value such as into the Monitor text box and click Send, and the blink delay will be set to milliseconds:

Each digit is converted from its ASCII value to its numeric value. Because the numbers are decimal numbers (base 10), each successive number is multiplied by For example, the value of the number is 2 * + 3 * 10 + 4. The code to accomplish that is:

If you want to handle negative numbers, your code needs to recognize the minus () sign. For example:

Another approach to converting text strings representing numbers is to use the C language conversion function called (for variables) or (for variables). These obscurely named functions convert a string into integers or long integers. To use them you have to receive and store the entire string in a character array before you can call the conversion function.

This code fragment terminates the incoming digits on any character that is not a digit (or if the buffer is full):

is a numeric string built up from characters received from the serial port.

(short for ASCII to integer) is a function that converts a character string to an integer ( converts to a long integer).

 Sending Multiple Text Fields from Arduino in a Single Message

You want to send a message that contains more than one piece of information (field). For example, your message may contain values from two or more sensors. You want to use these values in a program such as Processing, running on your PC or Mac.

The easiest way to do this is to send a text string with all the fields separated by a delimiting (separating) character, such as a comma:

Here is the Processing sketch that reads this data from the serial port:

The code in this recipe’s Solution will send the following text string to the serial port (indicates a carriage return and indicates a line feed):

You must choose a separating character that will never occur within actual data; if your data consists only of numeric values, a comma is a good choice for a delimiter. You may also want to ensure that the receiving side can determine the start of a message to make sure it has all the data for all the fields. You do this by sending a header character to indicate the start of the message. The header character must also be unique; it should not appear within any of the data fields and it must also be different from the separator character. The example here uses an uppercase H to indicate the start of the message. The message consists of the header, three comma-separated numeric values as ASCII strings, and a carriage return and line feed.

The carriage return and line-feed characters are sent whenever Arduino prints using the function, and this is used to help the receiving side know that the full message string has been received. A comma is sent after the last numerical value to aid the receiving side in detecting the end of the value.

The Processing code reads the message as a string and uses the Java method to create an array from the comma-separated fields.

The Processing website provides more information on installing and using this programming environment. See manicapital.com

 Receiving Multiple Text Fields in a Single Message in Arduino

You want to receive a message that contains more than one field. For example, your message may contain an identifier to indicate a particular device (such as a motor or other actuator) and what value (such as speed) to set it to.

Arduino does not have the function used in the Processing code in Recipe , but the functionality can be implemented as shown in this recipe. The following code receives a message with three numeric fields separated by commas. It uses the technique described in Recipe  for receiving digits, and it adds code to identify comma-separated fields and store the values into an array:

This sketch accumulates values (as explained in Recipe ), but here each value is added to an array (which must be large enough to hold all the fields) when a comma is received. A character other than a digit or comma (such as the newline character; see Recipe ) triggers the printing of all the values that have been stored in the array.

Another approach is to use a library called TextFinder, which is available from the Arduino Playground. TextFinder was created to extract information from web streams (see Chapter 15), but it works just as well with serial data. The following sketch uses TextFinder to provide similar functionality to the previous sketch:

You can download the TextFinder library from manicapital.com

Here is a summary of the methods supported by TextFinder (not all are used in the preceding example):

Chapter 15 provides more examples of TextFinder used to find and extract data from a stream.

 Sending Binary Data from Arduino

You need to send data in binary format, because you want to pass information with the fewest number of bytes or because the application you are connecting to only handles binary data.

This sketch sends a header followed by two integer (bit) values as binary data. The values are generated using the Arduino function (see Recipe ):

Sending binary data requires careful planning, because you will get gibberish unless the sending side and the receiving side understand and agree exactly how the data will be sent. Unlike text data, where the end of a message can be determined by the presence of the terminating carriage return (or another unique character you pick), it may not be possible to tell when a binary message starts or ends by looking just at the data—data that can have any value can therefore have the value of a header or terminator character.

This can be overcome by designing your messages so that the sending and receiving sides know exactly how many bytes are expected. The end of a message is determined by the number of bytes sent rather than detection of a specific character. This can be implemented by sending an initial value to say how many bytes will follow. Or you can fix the size of the message so that it’s big enough to hold the data you want to send. Doing either of these is not always easy, as different platforms and languages can use different sizes for the binary data types—both the number of bytes and their order may be different from Arduino. For example, Arduino defines an as two bytes, but Processing (Java) defines an as four bytes ( is the Java type for a bit integer). Sending an value as text (as seen in earlier text recipes) simplifies this problem because each individual digit is sent as a sequential digit (just as the number is written). The receiving side recognizes when the value has been completely received by a carriage return or other nondigit delimiter. Binary transfers can only know about the composition of a message if it is defined in advance or specified in the message.

This recipe’s Solution requires an understanding of the data types on the sending and receiving platforms and some careful planning. Recipe  shows example code using the Processing language to receive these messages.

Sending single bytes is easy; use. To send an integer from Arduino you need to send the low and high bytes that make up the integer (see Recipe  for more on data types). You do this using the and functions (see Recipe ):

The preceding code sends the low byte followed by the high byte. The code can also be written without the parameter (see Recipe ), but using the parameter is a useful reminder (when you come back later to make changes, or for others who may read your code) that your intention is to send bytes rather than ASCII characters.

Sending a long integer is done by breaking down the four bytes that comprise a in two steps. The is first broken into two bit integers; each is then sent using the method for sending integers described earlier:

First you send the lower bit integer value:

Then you send the higher bit integer value:

You may find it convenient to create functions to send the data. Here is a function that uses the code shown earlier to print a bit integer to the serial port:

The following function sends the value of a (4-byte) integer by first sending the two low (rightmost) bytes, followed by the high (leftmost) bytes:

These functions to send binary and values have the same name: . The compiler distinguishes them by the type of value you use for the parameter. If your code calls with a 2-byte value, the version declared as will be called. If the parameter is a value, the version declared as will be called. This behavior is calledfunction overloading. Recipe  provides another illustration of this; the different functionality you saw in is due to the compiler distinguishing the different variable types used.

You can also send binary data using structures. Structures are a mechanism for organizing data, and if you are not already familiar with their use you may be better off sticking with the solutions described earlier. For those who are comfortable with the concept of structure pointers, the following is a function that will send the bytes within a structure to the serial port as binary data:

Sending data as binary bytes is more efficient than sending data as text, but it will only work reliably if the sending and receiving sides agree exactly on the composition of the data. Here is a summary of the important things to check when writing your code:

 Receiving Binary Data from Arduino on a Computer

You want to respond to binary data sent from Arduino in a programming language such as Processing. For example, you want to respond to Arduino messages sent in Recipe 

This recipe’s Solution depends on the programming environment you use on your PC or Mac. If you don’t already have a favorite programming tool and want one that is easy to learn and works well with Arduino, Processing is an excellent choice.

Here are the two lines of Processing code to read a byte, taken from the Processing example (see this chapter’s introduction):

As you can see, this is very similar to the Arduino code you saw in earlier recipes.

The following is a Processing sketch that sets the size of a rectangle proportional to the integer values received from the Arduino sketch in Recipe 

The Processing language influenced Arduino, and the two are intentionally similar. The function in Processing is used to handle one-time initialization, just like in Arduino. Processing has a display window, and sets its size to × pixels with the call to .

The line selects the serial port—in Processing, all available serial ports are contained in the object and this example uses the value of a variable called . prints all the available ports, and the line opens the port selected as . Ensure that you set to the serial port that is connected to your Arduino.

The function in Processing works like in Arduino; it is called repeatedly. The code in checks if data is available on the serial port; if so, bytes are read and converted to the integer value represented by the bytes. A rectangle is drawn based on the integer values received.

 Sending Binary Values from Processing to Arduino

You want to send binary bytes, integers, or long values from Processing to Arduino. For example, you want to send a message consisting of a message identifier “tag,” an index (perhaps indicating a particular device attached to Arduino), and a bit value.

Use this code:

When the mouse is clicked in the Processing window, will be called with equal to the vertical position of the mouse in the window when clicked and equal to the horizontal position. The window size was set to ,, so would fit into a single byte and would fit into two bytes:

sends a header, tag, and index as single bytes. It sends the value as two bytes, with the most significant byte first:

The Arduino code to receive this and echo the results back to Processing is:

The next three s must mirror the definitions used in the sending program:

The check to ensure that at least have been received ensures that we don’t try to process the message until all the required data is available:

Only read the rest of the message if a valid header has been received:

The next lines convert the two bytes back to an integer. restores the most significant byte to its original value. Compare this to Processing code that sent the two bytes comprising the value:

If the code gets here, the tag was not recognized. This helps you to ignore data that may be incomplete or corrupted:

This code is similar to the Processing code in the previous recipes, with the addition of a function called . In this example, the function is called with three parameters: a tag, an index, and a value. The function first sends the header character to identify the start of the message. Then the single byte index is sent, followed by the two bytes that comprise the integer value. You can make your own version of this function to send the combination of values that you need for your application.

 Sending the Value of Multiple Arduino Pins

You want to send groups of binary bytes, integers, or long values from Arduino. For example, you may want to send the values of the digital and analog pins to Processing.

This recipe sends a header followed by an integer containing the bit values of digital pins 2 to This is followed by six integers containing the values of analog pins 0 through 5. Chapter 5