By the mid 19th century, the power of the Qing Dynasty was waning. Once a proud empire, the Qing Dynasty suffered a series of humiliations through various wars against European powers and the Empire of Japan (known historically as the century of humiliation). The unequal treaties that the empire had no choice but to sign caused China to cede control of various ports to these foreign powers (hence the reason why Hong Kong became part of the British Empire).

As the Qing Empire continued to be bullied, resentment grew among the people. Out of this resentment, eventually resulted in revolution. Sun Yat-sen tried on many separate occasions to overthrow the empire. Even after a string of failures and exile, he persisted, and eventually achieved his goal of overthrowing the empire and founding a republic.

The republic however was short lived. Plagued by power struggles, the republic fell apart. Sun Yat-sen passed away before he could see his successor, Chiang Kai-shek reunify the nation. But even that was short lived, once Japan began invading China and then the resumption of the Chinese Civil War almost immediately after.

See more pictures of Taipei here

Generally, communication with serial ports involves these steps (in no particular order):

• Searching for serial ports
• Connecting to the serial port
• Starting the input output streams
• Adding an event listener to listen for incoming data
• Disconnecting from the serial port
• Sending Data
• Receiving Data

I wrote an example program that includes all of those steps in it and are each in their own separate method within the class, but first I will go through my hardware set up.

Hardware Setup

My current hardware setup is as follows:

• PC connected to an XBee
• Arduino connected to an XBee

User input is given from the PC through the a Java GUI that contains code for serial communication, which is the code presented here.

The Arduino is responsible for reading this data.  This set up is pretty much using my computer as a remote control for whatever device is on the Arduino end.  It could be a motor control, on-off switch, etc.

Existing Code

The purpose of this post is to discuss serial programming in Java, and not GUI’s.  However, I did create a GUI for testing purposes.  See the Code Downloads section for the actual files.

Above is the picture of the GUI complete with the buttons that I use to interact with the program.  I also added key bindings which I can use to control the throttle.

When the program is first started, none of the GUI elements will work except for the combo box and the connect button.  Once a successful connection is made the controls are enabled.  This is done through the use of the setConnected(true) and the toggleControls() methods shown in the example code that follows.

Imports

The imports i used for this program were as follows:

import gnu.io.*;
import java.awt.Color;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.TooManyListenersException;

Depending on the Java IDE it might already know to tell you to use these imports except for the first one.  That first import is specific to RXTX, and all its library methods/classes are in there.

Class Declaration

The code here reads:

public class Communicator implements SerialPortEventListener

I named my class Communicator, but the name is really up to the programmer.  The name pretty much reflects its intended use.

The class should also implement the SerialPortEventListener class.  This is a class in RXTX and is required in order to receive incoming data.

On some IDE’s this may generate a public void method called serialEvent().  This method will be defined later.

Class Variables and Constants

Below are the variables and constants that I defined in my class.  What the variables are for is in the comments but a more detailed explanation will follow.

    //passed from main GUI
    GUI window = null;

    //for containing the ports that will be found
    private Enumeration ports = null;
    //map the port names to CommPortIdentifiers
    private HashMap portMap = new HashMap();

    //this is the object that contains the opened port
    private CommPortIdentifier selectedPortIdentifier = null;

I could have easily put the variable definitions in the constructor but it wouldn’t change anything.

The GUI object is another class that I wrote separate from this one that contains all the GUI elements.  The GUI class extends javax.swing.JFrame.

The HashMap is for mapping each of the ports’ names to the actual object. What that means is that I can associate (put() method) the name of a serial port, say a string that says COM1, to an object in the code.  Later, I can access the name COM1 from the HashMap by using the get() method and it will return the object that it was associated with previously.

The CommPortIdentifiers object is needed to gather the list of ports that are available for connection. by using its getPortIdentifiers() method.

The SerialPort object is for storing the data for the port once a successful connection is made.

The InputStream and OutputStream is the object that is required for sending and receiving data.

The Boolean variable bConnected is just a flag that I use for enabling and disabling elements on the GUI.

The constant TIMEOUT is a number required when opening the port so that it knows how long to try for before stopping.

The constants for the ASCII values are some values that I use to send through the output stream that act as delimiters for data.

The string logText is basically what the comment says.  When stuff happens in the program, the program stores a string in this variable and it will be appended to a text area in the GUI.

Searching for Available Serial Ports

The method below is for searching for available serial ports on the computer.  Code adapted from Discovering Available Comm Ports from the Reference Material.

    //search for all the serial ports
    //pre style="font-size: 11px;": none
    //post: adds all the found ports to a combo box on the GUI
    void searchForPorts()
    {
        ports = CommPortIdentifier.getPortIdentifiers();

        <span style="color: blue;">while (ports.hasMoreElements())
        {
            CommPortIdentifier curPort = (CommPortIdentifier)ports.nextElement();

            //get only serial ports
            <span style="color: blue;">if (curPort.getPortType() == CommPortIdentifier.PORT_SERIAL)
            {
                window.cboxPorts.addItem(curPort.getName());
                portMap.put(curPort.getName(), curPort);
            }
        }
    }

The method getPortIdentifiers() returns an Enumeration of all the comm ports on the computer.  The code can iterate through each element inside the Enumeration and determine whether or not it is a serial port.  The method getPortType() can identify what kind of port it is.  If it is a serial port, then the code will add its name to a combo box in the GUI (so that users can pick what port to connect to).  The serial port that is found should also be mapped to the HashMap so we can identify the object later.  This is helpful because the names listed in the combo box are the actual names of the object (COM1, COM2, etc), and so we can use these names to identify the actual object they are tied to.

Connecting to the Serial Port

The method below is for connecting to the serial port once they have been found (see previous section).  See How to Open A Serial Port in the Reference Material for more information.

    //connect to the selected port in the combo box
    //ports are already found by using the searchForPorts
    //method
    //post: the connected comm port is stored in commPort, otherwise,
    //an exception is generated
    public void connect()
    {
        String selectedPort = (String)window.cboxPorts.getSelectedItem();
        selectedPortIdentifier = (CommPortIdentifier)portMap.get(selectedPort);

        CommPort commPort = null;

        try
        {
            //the method below returns an object of type CommPort
            commPort = selectedPortIdentifier.open("TigerControlPanel", TIMEOUT);
            //the CommPort object can be casted to a SerialPort object
            serialPort = (SerialPort)commPort;

            //for controlling GUI elements
            setConnected(true);

            //logging
            logText = selectedPort + " opened successfully.";
            window.txtLog.setForeground(Color.black);
            window.txtLog.append(logText + "n");

            //CODE ON SETTING BAUD RATE ETC OMITTED
            //XBEE PAIR ASSUMED TO HAVE SAME SETTINGS ALREADY

            //enables the controls on the GUI if a successful connection is made
            window.keybindingController.toggleControls();
        }
        catch (PortInUseException e)
        {
            logText = selectedPort + " is in use. (" + e.toString() + ")";

            window.txtLog.setForeground(Color.RED);
            window.txtLog.append(logText + "n");
        }
        catch (Exception e)
        {
            logText = "Failed to open " + selectedPort + "(" + e.toString() + ")";
            window.txtLog.append(logText + "n");
            window.txtLog.setForeground(Color.RED);
        }
    }

Using the HashMap we can retrieve the CommPortIdentifier object from the string that was mapped earlier.  This is achieved through the HashMap’s get() method.  The object must also be casted as a CommPortIdentifier because the get() method has a return type of Object.

The setConnected method just changes a boolean flag so that the program can store whether or not it is connected to a serial port or not.

The CommPort must also be initialized because the port object will be stored here once a successful connection is made.

The main method of interest here is the open() method.  This instructs the program to open the port, and this method will return the object for the opened port, which I store in in the previously initialized CommPort object.  I then cast this object as a SerialPort and store it as well.  This is helpful for accessing the methods and variables specific to the SerialPort class.

It should also be noted that the open() method requires the use of a try-catch block.  So applying that, I catch two different exceptions.  The PortInUseException is what the name says.  If the port is in use, then this exception is thrown.  The next catch block is just for the generic exceptions that occur.  I never came across that during testing, nor do I know how to replicate that.

I neglected to include any code for setting the baud rate and other settings on the XBee’s (see Hardware Configuration), because I already set those parameters previously using X-CTU (more on setting up XBee’s here).

Initializing the Input and Output Streams

This method is pretty short and is pretty straightforward to read.

    //open the input and output streams
    //pre style="font-size: 11px;": an open port
    //post: initialized input and output streams for use to communicate data
    public boolean initIOStream()
    {
        //return value for whether opening the streams is successful or not
        boolean successful = false;

        try {
            //
            input = serialPort.getInputStream();
            output = serialPort.getOutputStream();
            writeData(0, 0);

            successful = true;
            return successful;
        }
        catch (IOException e) {
            logText = "I/O Streams failed to open. (" + e.toString() + ")";
            window.txtLog.setForeground(Color.red);
            window.txtLog.append(logText + "n");
            return successful;
        }
    }

The streams are initialized by returning the input and output streams of the open serial port.  In order for the serial port object to not be null, it must store the object for the open serial port.

The getInputStream() and getOutputStream() methods both require a try-catch block.  The important exception to catch here is the IOException to signify whether the streams failed to open or not.  For more information see How to Open A Serial Port in the Reference Material.

I also call a method called writeData(0, 0).  This is the method that encapsulates the code required to write serial data.  More on that later.  Right now it is just used to set variables on the microcontroller side to zero.

Setting Up Event Listeners to Read Data

Once the port is open, the serial port must know whenever there is data to be read.  This approach is event driven rather than by polling.  When the event is hit, a special block of code will run.  This is advantageous to polling because polling requires constantly asking if data is available.  The code for the event driven approach is below.  See Event Based Two Way Communication for more information.

    //starts the event listener that knows whenever data is available to be read
    //pre style="font-size: 11px;": an open serial port
    //post: an event listener for the serial port that knows when data is received
    public void initListener()
    {
        try
        {
            serialPort.addEventListener(this);
            serialPort.notifyOnDataAvailable(true);
        }
        catch (TooManyListenersException e)
        {
            logText = "Too many listeners. (" + e.toString() + ")";
            window.txtLog.setForeground(Color.red);
            window.txtLog.append(logText + "n");
        }
    }

The code here is pretty much the whole reason why this class implements SerialPortEventListener.  The parameter for adding the event listener is just the object itself.  The base class has a method called serialEvent(event) that should be overridden before the event code will work.  Overriding that method defines what happens when the event is hit.

The method addEventListener(this) is the event that is always checking for SerialEvents.  It isn’t really important to know what the events actually are, just that the one we’re interested in is the one that tells us whenever data is received.  Adding the event listener is complemented by the method notifyOnDataAvailable(true), which definitely helps us achieve what I mentioned previously.

This code requires a try-catch box.  The exception here is that there may be too many event listeners.  I only use one in the code, so this exception should never be hit.

Disconnecting from the Serial Port

Once all the communication is completed, the serial port must be disconnected.  In some instances, some ports stay stuck open, which isn’t exactly a good thing.

    //disconnect the serial port
    //pre style="font-size: 11px;": an open serial port
    //post: closed serial port
    public void disconnect()
    {
        //close the serial port
        try
        {
            writeData(0, 0);

            serialPort.removeEventListener();
            serialPort.close();
            input.close();
            output.close();
            setConnected(false);
            window.keybindingController.toggleControls();

            logText = "Disconnected.";
            window.txtLog.setForeground(Color.red);
            window.txtLog.append(logText + "n");
        }
        catch (Exception e)
        {
            logText = "Failed to close " + serialPort.getName()
                              + "(" + e.toString() + ")";
            window.txtLog.setForeground(Color.red);
            window.txtLog.append(logText + "n");
        }
    }

The code here requires a try-catch block so there it is.  The exception to catch here is pretty generic.

Before closing the port, I reset the data on the microcontroller.  That step is optional depending on the application.  For example, if the value sent to the microcontroller is controlling the speed of a motor, I’d want the motor to turn off if I turn off the remote control.

The event listener should be removed as it is no longer needed.

The method to close the port is the close() method.

The input and output streams should also be closed via the same method as above.

See How to Close A Serial Port in the Reference section for more information.

Reading Data – The serialEvent Method

This is a follow-up to the section on preparing to Read Data.  It has information on how to process the data that the program reads.

    //what happens when data is received
    //pre style="font-size: 11px;": serial event is triggered
    //post: processing on the data it reads
    public void serialEvent(SerialPortEvent evt) {
        if (evt.getEventType() == SerialPortEvent.DATA_AVAILABLE)
        {
            try
            {
                byte singleData = (byte)input.read();

                if (singleData != NEW_LINE_ASCII)
                {
                    logText = new String(new byte[] {singleData});
                    window.txtLog.append(logText);
                }
                else
                {
                    window.txtLog.append("n");
                }
            }
            catch (Exception e)
            {
                logText = "Failed to read data. (" + e.toString() + ")";
                window.txtLog.setForeground(Color.red);
                window.txtLog.append(logText + "n");
            }
        }
    }

Since we only want to read data if it exists, we test the condition in the if statement above.  This could be redundant because we wouldn’t be in this method if the event never got triggered.

Reading the data requires a try-catch block.  The read() method returns an integer, but the value in it is actually a byte value so this is casted to a byte, in which I store in a variable called singleData.  When I was testing this code before, I noticed that the data being read would always have random new line characters in it, and I never knew why this happened.  I never wrote any new line characters.  Since I don’t want these, I add an if condition saying that if it encounters that, don’t display that data on the screen.

Java also has a nice way of converting bytes to a string.  A byte array can be used as a parameter when initializing a string, which is what I’ve done when I assign a value to logText.

The exception here is just the usual generic one.

Writing Data

Here is the method for writing data.  In my application, I am writing two integers sequentially to my microcontroller.  Data that is sent to the MCU can be used for such things such as controlling motor speeds, which is what I am trying to do here.  I hope to use the data sent do control the PWM duty cycle of the motor for speed control.

    //method that can be called to send data
    //pre style="font-size: 11px;": open serial port
    //post: data sent to the other device
    public void writeData(int leftThrottle, int rightThrottle)
    {
        try
        {
            output.write(leftThrottle);
            output.flush();
            //this is a delimiter for the data
            output.write(DASH_ASCII);
            output.flush();

            output.write(rightThrottle);
            output.flush();
            //will be read as a byte so it is a space key
            output.write(SPACE_ASCII);
            output.flush();
        }
        catch (Exception e)
        {
            logText = "Failed to write data. (" + e.toString() + ")";
            window.txtLog.setForeground(Color.red);
            window.txtLog.append(logText + "n");
        }
    }

The write() method here requires a try-catch block just like many of the other methods used for serial communication.  Using the output stream, I call that method to write an integer value.  I also write a dash and a space to separate the actual data being read.  See the ASCII Table for the values of what these characters should be.  This helps me differentiate the sets of data that is sent back and forth.  The dash separates the two integers being sent and the space separates the entire set.  On the Arduino end, four called to read() can separate the data without mixing things up.  Example of that later.

Putting All the Java Code Together

Once all these methods are setup, they need to be called somewhere in the program so we can put them to use.  When the program starts, the code for searching for serial ports will run so that it can populate the combo box on the GUI.  The GUI buttons also need to be disabled to reflect the fact they should be disabled when there is no connection to a port.  When the connect button is pressed, the input and output streams are started and the event listener is added.  The code for that is shown below.

        private void btnConnectActionPerformed(java.awt.event.ActionEvent evt) {
            communicator.connect();
            if (communicator.getConnected() == true)
            {
                if (communicator.initIOStream() == true)
                {
                    communicator.initListener();
                }
            }
        }

The if statement is needed such that the code will not run if a successful connection was not made.  This is the precondition for the initIOStream() and the initLIstener() methods.

When the user decides to disconnect from the serial port, the user only needs to call the disconnect() method when the disconnect button is pressed.

The up/down arrows on my GUI are set to write data to the serial port when they are pressed.  When data is written to the Arduino, the MCU will send the data back to the Java program, which will signal the event listener to display that data back to the screen.

Arduino Code

The Arduino code is pretty straight forward.  There are just a few calls to the read() method.

Update 6 May 2012: the syntax for the Arduino code has updated since the writing of this article.  Apparently, the lines

Serial.print(separator, BYTE);
Serial.print(space, BYTE);

are no longer valid and have since been replaced by the following:

Serial.write(byte(separator));
Serial.write(byte(space));

The code below hasn’t been edited with this change, but basically the code required for writing a byte value through serial communication has changed.

// this is where we will put our data
int left = 0;
int right = 0;
byte space = 0;
byte separator = 0;

void setup(){
  // Start up our serial port, we configured our XBEE devices for 38400 bps. 
  Serial.begin(9200);
}

void loop(){
  // handle serial data, if any
  if (Serial.available() >= 4){
    left = Serial.read();
    separator = Serial.read();
    right = Serial.read();
    space = Serial.read();
    Serial.flush();

    Serial.print(left);
    Serial.print(separator, BYTE);
    Serial.print(right);
    Serial.print(space, BYTE);
    Serial.print("n");
  }
}

I first declare four variables to reflect the fact that I’m writing four different variables to the serial port.

In the loop method, I added a condition which will check whether there are four pieces of data available before reading them.  This again reflects the fact I’m writing four values.

The four variables initially declared store the values in the order that they are written, and then are just printed to the screen.

The print() method is able to convert the byte value to an actual character by adding a second parameter called BYTE.  The left and right variables don’t need it because the values written were integers to begin with, however, the dash and space characters were written as ASCII values.

For more information about Arduino and Java, and Arduino’s Serial library, please refer to those in the Reference Section.

Code Downloads

Here are the code downloads for the GUI, key bindings and the serial communication.  WordPress doesn’t allow uploads of zip or java files so I uploaded it all to Megaupload.

Link to download: http://www.mediafire.com/?z2l26ncypmzn20z

Other Examples

There are also other sites I looked at which had example code for serial port communication in Java.  The sites are Programming Serial and Parallel Ports and Serial Port Access Using RXTX in Java, which are both in the Reference section.

Reference Material

Below are a bunch of links to reference sites that I used to find some of the information written here.  I mostly referred to bits and pieces of each article to understand the serial code and to come up with the example I present here.  The list is in the order that I referenced them.

Discovering Available Comm Ports

http://rxtx.qbang.org/wiki/index.php/Discovering_available_comm_ports

The code on this page is pretty specific to the title of this heading, and the code is pretty easy to follow.

How to Open A Serial Port

http://embeddedfreak.wordpress.com/2008/08/08/how-to-open-serial-port-using-rxtx/

This page provides a very concise and detailed explanation on what each line of code does in order to get a serial port open.  Definitely work a look if you’re trying to understand the code.

Event Based Two Way Communication

http://rxtx.qbang.org/wiki/index.php/Event_Based_Two_Way_Communication

This page has example code on how to connect to a serial port and how to interact with it.  The code here uses events, rather than polling, to send data back and forth, which means that whenever data is received, the event code is triggered.

How to Close A Serial Port

http://embeddedfreak.wordpress.com/2008/08/08/how-to-close-serial-port-in-rxtx/

This article is written by the same author who wrote the article on how to open serial ports.  Good example code here.

ASCII Table

http://www.asciitable.com/

Having the ASCII Table is quite handy for serial data because data being sent and written are bytes, so being able to know what byte values correspond to what character really helps.

Arduino and Java

http://www.arduino.cc/playground/Interfacing/Java

This article discusses how to use the serial port communication with Java and Arduino, which is exactly what I am after.  It has example code on pretty much the entire process of serial port communication, but it may be too much to read since there is little explanation about the code.

Arduino Serial Class

http://arduino.cc/en/Reference/Serial

A good reference for Arduino’s Serial class methods.  Also has example code to look at.

Programming Serial and Parallel Ports

This article provides a brief introduction to programming serial ports and has information on the steps required to talk to the serial port.  However, the code examples in there may be hard to follow for someone new to serial programming.

Serial Port Access Using RXTX in Java

http://gomultidomain.blogspot.com/2008/06/serial-port-access-using-rxtx-in-java.html

This page also has complete code for serial communication in Java, but what I was looking for here was how to use the write method to send serial data from Java.

Computer Specs:

Intel Core 2 Duo T5250 Processor
2 GB RAM @ 667 Ghz
Intel GM965 Chipset
nVidia GeForce 8600M GT
Dell Wireless 1390 802.11g

Installation

I was lucky enough to only need the Retail Snow Leopard Disc (10A432) and the myHack Installer 1.0.1.  I pretty much followed METHOD 2 in this guide (method 1 didn’t really work out for me, but it might have had something to do with the disc restoration part of the guide):

http://prasys.co.cc/2009/08/installing-snow-leopard-for-osx86/

For the myHack installer, check the box for the kext that says something about PS2 in it.  It will enable the laptop touchpad and keyboard.  Also, read the description for each kext to see if you need it or not.

When I used method 1 in the guide, I had some trouble with an installation error that said “Could not verify BaseSystem.pkg” or something along those lines.  That error appeared at about 10-15% installation progress.  It went away then I used method 2.  I did read somewhere that it may have had to do with the restoration in Disk Utility.  Either way, it worked the second time around.

Once SL was installed, I ran the myHack Installer on my drive to get the Chameleon Bootloader on there so I wouldn’t have to use my USB to boot all the time.  Also, be sure not to install GraphicsEnabler as it will prevent your computer from shutting down completely (more on that later).

Graphics

Since my laptop uses an nVidia card, there is an issue that prevents the computer from shutting down completely if the “GraphicsEnabler” option is used in the myHack Installer.  I believe NVInject, NVKush, and NVDarwin all suffer from this same problem.  What happens is that when the shut down command is invoked, the computer’s screen will turn off, the HD will turn off, but the power stays on.  When the nVidia graphics kexts aren’t used, this problem goes away.

I’ve tried generating an EFI String and loading that with EFI Studio, but it didn’t do the job.  The resolution is still 1024×768 and I have no QE, CI or OpenGL support.  What I did later on was install PC EFI to see if that would fix things (I didn’t really know what I was doing here at this point).  That didn’t really work, but I did later find out that EFI Studio allows me to add boot flags.  I added “Graphics Mode”=”1280x800x32” to the boot flag so now it boots with the proper resolution.  It gives the proper resolution, but still no QE/CI or OpenGL.  This guide has information on how to test for QE (Quartz Extreme) and CI (Core Image): http://prasys.co.cc/tag/enable-qeci/

Another thing I tried was to modify my DSDT to get my graphics card working using this link: http://tonymacx86.blogspot.com/2010/01/advanced-dsdt-fixes-nvidia-graphics.html.  I managed to get the card recognized using the DSDT code, but when I got rid of the graphics kexts, and the boot.plist options as specified in the guide, I lost my graphics acceleration.  I know my DSDT code is working here still since System Profiler tells me what card I have with the exact same names that I gave in the DSDT.  It seems that having graphics acceleration and shutdown/restart working properly just isn’t meant to be.

The tradeoff:

I either could have proper graphics acceleration and no shutdown, OR I could have shut down and no graphics acceleration.  Graphics is the clear winner here, but I still hate having no shutdown.  I have not found a fix for this.

Power Management

There was a problem with high CPU temperatures with the laptop.  I installed the VoodooPowerMini kext located here (http://forum.voodooprojects.org/index.php/topic,1095.0.html)

Audio

After looking for various kexts, I found that VoodooHDA worked for me.  It can be found here (http://www.kexts.com/view/70-voodoohda_(32–_64-bit,_recompiled_by_prasys).html).

Wireless

Works after installation.

USB Ports

They work since it can recognize my mouse and USB drive.

Battery Indicator

I used the VoodooBattery kext located here (http://forum.voodooprojects.org/index.php/topic,1092.0.html)

Card Reader

I don’t use this so I didn’t install the kext for it.  It can be found here: http://www.dailyblogged.com/retail-snow-leopard-installation-guide/ or SD Card Fix (more direct).

Touchpad

I had an issue where I couldn’t tap the touchpad in order for it to “click”.  I fixed this issue by installing the VoodooPS2Controller kext (check the Trackpad option during the installation) (http://forum.voodooprojects.org/index.php/topic,235.0.html).  Then I installed the preference pane (this allows configuring the Trackpad through System Prefs) here http://www.dailyblogged.com/retail-snow-leopard-installation-guide/ (command -f to find it).  I opened System Preferences and pressed the Show All button, and I saw a “Trackpad” option, so I opened it and the option was there.

Webcam

Works after installation.

Conclusion

Everything I listed here works except for video and the card reader.  There are other things like Ethernet, but I don’t really use it.

For example:

string str = " TEST STRING "; //there is a space in the beginning and end
cout << str.find_first_not_of(" ") << endl; //this line will return a 1, because thats the first thats not of a " 

To get rid of the leading and trailing spaces in that string, we can do this:

str = str.substr(str.find_first_not_of(" ")); //str will now be assigned "TEST STRING ", note that there is still a space at the end

str = str.substr(0, str.find_last_not_of(" ") + 1) //now the trailing space is removed.  a 1 is added because without it, we would get "TEST STRIN" instead.  the 1 ensures that only the space is removed

If the string that is being converted is actually not a number, then it will return a zero.

Conditional – decides which set of actions that the program will perform depending on a programmer specified condition

Constant – a special kind of variable whose value cannot change during program execution

Control structure – refers to the order in which the individual statements, instructions, or function calls of an imperative or a declarative program are executed or evaluated

Data structure – ways that data can be organized within a program

Data type – different varieties that data can be represented within a program

Directive – used to describe how the parts of a program are to be used to built a complete program

Identifier – programmer-specified name; a sequence of characters associated with and used to access a variable, particular object, class or struct, or function. Every identifier has a scope

Iteration – a single execution of a set of instructions that are to be repeated; “the solution took hundreds of iterations”

Keyword – a word that has particular meaning to the programming language and describes how a program is to work

Literal – a notation for representing a fixed value in source code. For example, the literal 12 represents the integer value “twelve”, “Morning” represents the character string value “Morning” and true represents the Boolean value true. They describe the type of value data has

Naming structure – rules for how data values, variables, operators, and other language constructs are referred to within the language

Operator – special symbols that specify how data is to be manipulated. For example, a ++ is an operator

Pragma – data embedded in source code by programmers to indicate some intention to the compiler

Sequential execution – execution by a computer if instructions in a program, performed in the sequence established by a programmer

Subprogram – a part of the code that is reused in various parts of the program

Variable – remembers data values for use within a program

Variable declaration – defining a variable’s type and name (identifier)

UPDATE: This set of instructions works for the Office 2010 Technical Preview as well.

Based on: https://answers.microsoft.com/en-us/msoffice/forum/all/trying-to-install-office-2010-but-getting-error/4a5e022f-13f1-42bb-ad66-f6dccfd44d40

To automatically uninstall the 2007 Microsoft Office suite, follow the steps in the following Microsoft Knowledge Base article: http://support.microsoft.com/kb/971179/

How do I uninstall the 2007 Office suites if I cannot uninstall it by using the “Add or Remove Programs” feature?

The steps provided in the ‘More Information’ section of this article provide the details of the removal performed by the solution in 971179.

You may find it easier to follow the steps if you print this article first.

First, verify that you cannot uninstall the 2007 Microsoft Office system by using Add or Remove Programs (or Programs and Features)

To verify that you cannot uninstall the 2007 Microsoft Office system by using Add or Remove Programs (or Programs and Features in Windows Vista), follow these steps.

For Windows XP or Windows Server 2003:

1. Click Start, click Run, type control appwiz.cpl in the Open box, and then press ENTER.
2. Click to select the 2007 Office system product from the application list, and then click Remove.

For Windows Vista:

1. Click Start, type prgrams and features in the Search box, and then press ENTER.
2. Click to select the product to be uninstalled from the listing of installed products, and then click Uninstall/Change from the bar that displays the available tasks.

If you were able to uninstall the 2007 Microsoft Office system by using Add or Remove Programs, you are finished. If you were unable to uninstall the 2007 Microsoft Office system, you may have issues with the Add or Remove Programs dialog box, or some 2007 Microsoft Office components may not be uninstalled. In these cases, you may be unable to reinstall the 2007 Microsoft Office system. Go to the next section to uninstall the 2007 Microsoft Office system by using an alternative method.

If Add or Remove Programs does not uninstall the 2007 Microsoft Office system, use this alternative method to uninstall

Use this method only if the Add or Remove Programs method did not work for you. Using this method does not completely uninstall the 2007 Microsoft Office system. After you use this method, you can reinstall the 2007 Microsoft Office system.

Note You must be logged on to Windows with a user account that is a computer administrator to complete this method. If this is your personal computer, you are likely already logged on with an administrator account. If this is a computer that is part of a network, you might have to ask the system administrator for help.

To uninstall the existing 2007 Microsoft Office system if you cannot uninstall it by using the Add or Remove Programs feature, follow these steps:
Step 1: Remove any remaining Windows Installer packages of the 2007 Microsoft Office system:

1. Click Start, click Run, type installer, and then click OK.
   This process opens the %windir%Installer folder.
2. On the View menu, click Details.
   Important To use the View menu in Windows Vista, you must press the ALT key first to display the menu bar, and then click the View menu.
3. On the View menu, click Choose Details.
4. Click to select the Subject check box, type 340 in the Width of selected column (in pixels) box, and then click OK.
   Note It may take several minutes for the subjects to appear next to each .msi file.
5. For Windows XP or Windows Server 2003, on the View menu, point to Arrange icons by, and then click Subject.
   For Windows Vista, on the View menu, point to Sort By, and then click Subject. In Windows Vista, a User Account Control dialog box may be displayed with the following warning:
   An unidentified program wants access to your computer

   Click Allow when you see this warning message.

6. For each .msi file where the subject is “Microsoft Office Product_Name 2007,” right-click the .msi file, and then click Uninstall.
   Note Product_Name is a placeholder for the name of the 2007 Microsoft Office product.

Step 2: Stop the Office Source Engine service:

1. For Windows XP and Windows Server 2003, click Start, click Run, type services.msc in the Open box, and then click OK.
   For Windows Vista, click Start, click Start Search, type services.msc, and then press ENTER.
2. In the Services window, determine whether the Office Source Engine service is running. If this service is running, right-click Office Source Engine, and then click Stop.
3. Close the Services window.

Step 3: Remove any remaining 2007 Microsoft Office installation folders

1. For Windows XP and Windows Server 2003, click Start, click Run, type %CommonProgramFiles%\Microsoft Shared in the Open box, and then click OK.
   For Windows Vista, click Start, click Start Search, type %CommonProgramFiles%\Microsoft Shared, and then press ENTER.
   Note On a computer that is running a 64-bit version of Windows Vista, type %CommonProgramFiles(x86)%\Microsoft Shared, and then press ENTER.
2. If the following folders are present, delete them:
   • Office12
   • Source Engine
3. For Windows XP and Windows Server 2003, click Start, click Run, type %ProgramFiles%\Microsoft Office, and then click OK.
   Note On a computer that is running a 64-bit version of Windows XP, type %ProgramFiles(x86)%\Microsoft Office, and then press ENTER.
   For Windows Vista, click Start, click Start Search, type %ProgramFiles%\Microsoft Office, and then press ENTER.
   Note On a computer that is running a 64-bit version of Windows Vista, type %ProgramFiles(x86)%\Microsoft Office, and then press ENTER.
4. On the root folder of each hard disk drive, locate and then open the MSOCache folder. If you cannot see the MSOCache folder, follow these steps:
   1. Open Windows Explorer, and then on the Tools menu click Folder Options.
   2. Click the View tab.
   3. In the Advanced settings pane under Hidden files and folders, click Show hidden files and folders.
   4. Click to clear the Hide protected operating system files check box, and then click OK.
5. Open the drive_letter:\MSOCache\All Users folder, and then delete every folder that has the following text in the folder name: 0FF1CE

   Note This text contains a zero and a one for the letters “O” and “I.”

Step 4: Remove any remaining 2007 Microsoft Office installation files

1. For Windows XP and Windows Server 2003, click Start, click Run, type %appdata%\microsoft\templates, and then click OK.
   For Windows Vista, click Start, click Start Search, type %appdata%\microsoft\templates, and then press ENTER.
2. Delete the following files:
   • Normal.dotm
   • Normalemail.dotm
3. For Windows XP and Windows Server 2003, click Start, click Run, type %appdata%\microsoft\document building blocks\Language_ID, and then click OK.
   For Windows Vista, click Start, click Start Search, type %appdata%\microsoft\document building blocks\Language ID, and then press ENTER.
   Notes
   • If you cannot open this folder because the folder does not exist, go to step 6.
   • Language_ID is a placeholder for the four-digit number that represents the language of the 2007 Microsoft Office system. For example, if you use the English version of the 2007 Microsoft Office system, the Language_ID value is 1033. If the Language_ID is not known, type %appdata%microsoftdocument building blocks, and then open the subfolder in that location.
4. Delete the Building blocks.dotx file.
5. For Windows XP and Windows Server 2003, click Start, click Run, type %temp%, and then click OK.
   For Windows Vista, click Start, click Start Search, type %temp%, and then press ENTER.
6. On the Edit menu, click Select All.
7. On the File menu, click Delete.
8. For Windows XP and Windows Server 2003, click Start, click Run, type %AllUsersprofile%\Application Data\MicrosoftOfficeData, and then click OK.
   For Windows Vista, click Start, click Start Search, type %AllUsersprofile%\Application DataMicrosoftOfficeData, and then press ENTER.
9. Delete only the Opa12.dat file.

Step 5: Remove the registry subkeys of the 2007 Microsoft Office system

Important: This section, method, or task contains steps that tell you how to modify the registry. However, serious problems might occur if you modify the registry incorrectly. Therefore, make sure that you follow these steps carefully. For added protection, back up the registry before you modify it. Then, you can restore the registry if a problem occurs. For more information about how to back up and restore the registry, click the following article number to view the article in the Microsoft Knowledge Base: http://support.microsoft.com/kb/322756/

1. Locate and then delete the registry subkeys of the 2007 Microsoft Office system if they are present. To do this, follow these steps:
   1. For Windows XP and Windows Server 2003, click Start, click Run, type regedit, and then click OK.
      For Windows Vista, click Start, click Start Search, type regedit, and then click OK.
   2. Click the following subkey:
      HKEY_CURRENT_USER\Software\Microsoft\Office\12.0
   3. On the File menu, click Export, type DeletedKey01, and then click Save.
   4. On the Edit menu, click Delete, and then click Yes to confirm the deletion.
   5. For each registry subkey in the following list, repeat steps 1a through 1d. Change the name of the exported key by one for each subkey.
      For example, type DeletedKey02 for the second key, type DeletedKey03 for the third key, and so on.
      Note In the following registry keys, the asterisk character (*) represents one or more characters in the subkey name.
      32-bit versions of Microsoft Windows:
      • HKEY_CURRENT_USER\Software\Microsoft\Office\12.0
      • HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Office\12.0
      • HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Office\Delivery\SourceEngine\Downloads\*0FF1CE}-*
      • HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\*0FF1CE*
      • HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Installer\UpgradeCodes\*F01FEC
      • HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Installer\UserData\S-1-5-18\Products\*F01FEC
      • HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\ose
      • HKEY_CLASSES_ROOT\Installer\Features\*F01FEC
      • HKEY_CLASSES_ROOT\Installer\Products\*F01FEC
      • HKEY_CLASSES_ROOT\Installer\UpgradeCodes\*F01FEC
      • HKEY_CLASSES_ROOT\Installer\Win32Assemblies\*Office12*

        64-bit versions of Microsoft Windows:

      • HKEY_CURRENT_USER\Software\Microsoft\Office\12.0
      • HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\Office\12.0
      • HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\Office\DeliverySourceEngineDownloads\*0FF1CE}-*
      • HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\Windows\CurrentVersion\Uninstall\*0FF1CE*
      • HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\Windows\CurrentVersion\Installer\UpgradeCodes\*F01FEC
      • HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\Windows\CurrentVersion\Installer\UserData\S-1-5-18\Products\*F01FEC
      • HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\ose
      • HKEY_CLASSES_ROOT\Installer\Features\*F01FEC
      • HKEY_CLASSES_ROOT\Installer\Products\*F01FEC
      • HKEY_CLASSES_ROOT\Installer\UpgradeCodes\*F01FEC
      • HKEY_CLASSES_ROOT\Installer\Win32Assemblies\*Office12*
2. Locate the following registry subkey:
   HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall

   Note On a computer that is running a 64-bit version of Windows, locate the following registry subkey instead:

   HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\Windows\CurrentVersion\Uninstall
3. On the File menu, click Export, type UninstallKey01, and then click Save.
4. Under the Uninstall subkey that you located in step 2, click each subkey, and then determine whether the subkey has the following value assigned to it:
   • Name: UninstallString
   • Data: file_name path\Office Setup Controller\Setup.exe path
     Note In this example, file_name is a placeholder for the name of an installation program, and path is a placeholder for the file path.
5. If the subkey contains the name and the data that are described in step 4, click Delete on the Edit menu. Otherwise, go to step 4.
6. Repeat steps 4 and 5 until you locate and then delete every subkey that matches the name and the data that are described in step 4.
7. Close Registry Editor.

Step 6: Restart the computer

Restart the computer. If the uninstall was successful, you are finished and can now reinstall the 2007 Microsoft Office system if you want. If the uninstall was not successful, go to the “Next Steps” section.

Additional registry information

HKEY_CURRENT_USER\Software\Microsoft\Office\Common\UserInfo

Shadow subkeys for Windows Server 2003 and for earlier versions of Windows Server:

HKEY_LOCAL_MACHINE\Software\Microsoft\Windows NT\CurrentVersion\Terminal Server\Install\Software\Microsoft\Office\12.0

Shadow subkeys for Windows Server 2008:

HKEY_LOCAL_MACHINE\Software\Microsoft\Windows NT\CurrentVersion\Terminal Server\Install\Software

Source: http://support.microsoft.com/default.aspx/kb/928218