In addition to being a great ‘one-stop shop’ for event content, we also benefit from other Channel 9 goodness, like using a ‘jump to time’ link to get to the best part of a PDC keynote !

Below is the basic hardware setup of the Laser Graffiti System.

Building a Laser Tracker Engine

Giving Sight to the Blind

The very first thing that needed to be proven was the ability to track a laser point. The most obvious solution was to give our application some vision with a webcam. Since this was going to be a WPF application, I decided to use my open-source project, WPF MediaKit, which comes with a webcam control called the VideoCaptureElement.

At the time, VideoCaptureElement was not very robust, and it occurred to me that my control wasn't very useful beyond looking at your webcam in a WPF app! I needed a way to get high-performance access to every pixel of every frame the webcam spat out. This was a good time to add that ability and increase value in my project. Without getting into the gory details of DirectShow and p/invoke, I was able to add a hook to pass me the pixel buffer, where I would wrap it in a Bitmap class and raise an event for each frame.

The XAML required to get each video sample from the web camera.

<MediaKit:VideoCaptureElement LoadedBehavior="Play"
    RenderOptions.BitmapScalingMode="LowQuality"
    UnloadedBehavior="Manual"
    DesiredPixelWidth="{Binding DesiredPixelWidth}"
    DesiredPixelHeight="{Binding DesiredPixelHeight}"
    VideoCaptureDevice="{Binding SelectedItem, ElementName=videoCapDevices}"
    FPS="30"
    EnableSampleGrabbing="True"
    NewVideoSample="VideoCaptureElement_NewVideoSample"
    Margin="0"
    x:Name="videoElement"
    Stretch="Fill"
    MinHeight="380"
    MinWidth="500" />

Did I Mention Lasers?

Now that I had the ability to look at every pixel sent to me, I needed to make sense of it all. In order to complete the project, we have to be able to find a laser point shined on a wall. The difficulty lies in the fact that a laser can be of varying size and color. For example, if you take two consecutive video frames with the same green laser point, you will find the point may slightly differ between the two. This is because we are dealing with analog data and slightly changing lighting conditions. Whatever algorithm we choose to find the laser must take this into account.

There are many advanced ways to use video analytics to find the laser pointer, but this project did have a deadline, and I wanted to keep it fun, so I went with a simple method, which allows a user to filter the video based off ranges of hue, saturation, and luminance. To do this, we make use of the AForge image processing library. AForge is an open-source library that comes with tons of useful utilities for just what we want to do.

Filtering pixels and counting blobs…

As previously mentioned, we need to first filter the image based on hue, saturation, and luminance. Luckily, the AForge library comes with such a filter, so there is not much work to be done here:

/* This AForge class helps us filter out the pixels we do not want */
var hsl = new HSLFiltering
{
    Hue = new IntRange(HueMinimum, HueMaximum),
    Saturation = new DoubleRange(SaturationMinimum, SaturationMaximum),
    Luminance = new DoubleRange(LuminanceMinimum, LuminanceMaximum)
};

var bitmapData = bitmap.LockBits(
    new Rectangle((int)targetSearchArea.X, 
        (int)targetSearchArea.Y, 
        (int)targetSearchArea.Width, 
        (int)targetSearchArea.Height),
    System.Drawing.Imaging.ImageLockMode.ReadWrite, 
    m_lastBitmap.PixelFormat);


/* Apply the AForge filter.  Doing it "in place" is more efficient as
 * new bitmap does not have to be allocated and copied */
hsl.ApplyInPlace(bitmapData);

So, what needs to be done now that we have a filtered image showing only a laser dot? The answer: Blob counting! A blob, in the context of video analytics, is a set of pixels that are all touching, and AForge comes with a class ready to tackle that too!

The AForge blob counter takes in a gray-scale image for processing, and then returns all blobs found in the image. The information included on a blob includes the rectangular pixel area where the laser was found in the video frame. The center of that area should be the center of our laser. It's important to note that if the HSL filter is improperly calibrated, we will get an overabundance of blobs and there will accordingly be no way we can tell if it is the laser point or not.

/* Create an initialize our blob counter */
var blobsCounter = new BlobCounter
    {
       FilterBlobs = true,
       ObjectsOrder = ObjectsOrder.Size,
       MinHeight = BlobMinimumHeight,
       MinWidth = BlobMinimumWidth,
       MaxWidth = 25,
       MaxHeight = 25
    };

/* We first let the blob counter process our image */
blobsCounter.ProcessImage(grayImage);

/* Retrieve a list of blobs that were found */
Blob[] blobs = blobsCounter.GetObjects(grayImage);

The early laser tracking prototype. We can literally have it track anything, based off color.

Building the Laser Graffiti Application

Our Rocket Engine Needs a Rocket

At this point, I had a working proof of concept and a laser tracker. What I needed now was an application to use it. You know, the laser-graffiti application.

There are many ways to construct a WPF application and one pattern that's been getting a little bit of traction is MVVM. I chose to make a composite application using Prism and MVVM. Prism is a great guidance library pack for making composite WPF applications with tons of tools to help in common scenarios.

Composite What? Huh?

When developing applications, usually of the larger variety, things can become complex. Complexity turns into a mess. A mess turns into time investment. Time investment turns into money. The more money spent, the fewer bonuses you will receive. To make sure we get that end-of-year pay raise, we want to control complexity from the get-go by making our code and our internal systems loosely coupled. A composite application is just a collection of loosely coupled systems that is composited at runtime.

The advantages of a composite application are:

· Components can be developed independently

· Components can be swapped out more easily than if they were tightly coupled

· The application remains extendable, meaning you can more easily extend your application

· Maintenance is much clearer with less chance of breaking other components

· Unit testing is more feasible

Composite Application Entrails

There are many, many excellent resources about Prism available on the internet, so I'd rather not compete with them. I did, however, want to cover the basics, and at least how I've used it within the Laser Graffiti application.

The Shell Assembly – This contains the main entry point of the application and the initial or main UI container for the application. Before anything else, this assembly will initialize something called a bootstrapper. The bootstrapper simply does any pre-initialization that needs to be done before initializing the rest of the application.

Module Assemblies – Each module assembly can be considered a component. The bootstrapper initializes each component and then the module spins up any application services and adds any user interface to the shell. For instance, the MediaKit module handles the capture of the video and the AForgeModule handles the vision routines.

The Infrastructure Assembly – This contains any base classes, well known/shared interfaces or general infrastructure code. Simply put, most if not all modules will have reference to this.

Rendering the Graffiti

I needed a way to draw the graffiti to a projector. Overall, this will be accomplished by drawing the graffiti to a window. The window will be set to maximized with no border. I also needed to write the code to draw the graffiti. Initially, I just used the WPF InkCanvas control, but I found it wasn't well tuned for what I wanted to do with it. So, I decided XNA would give the most performance and flexibility with the level of effects desired for drawing graffiti.

I had never really done any XNA development, so this project is certainly not built using best practices. The important part to notice is that the project is more or less a regular XNA application with the exception that the executable is added as a library reference. This is because we instantiate the XNA from our WPF application's process. The following snippet of code accomplishes this:

private void ShowGraffitiWall(bool show)
{
    if (m_game != null)
        m_game.Exit();

    if (!show) 
        return;

    var t = new Thread((ThreadStart)delegate
    {
        m_game = new XnaGraffitiGame();
        m_game.SetScreen(m_lastScreen);
        m_game.Effect = m_lastGraffitiEffect;
        m_game.Run();
        m_game.Dispose();
    });

    t.SetApartmentState(ApartmentState.STA);
    t.IsBackground = true;
    t.Start();
}

We instantiate the XNA window this way because it allows our WPF code to send the XNA messages of where the laser pointer was detected.

Drawing with the GPU

A blanket statement about XNA is that it is a drawing API. XNA applications can get quite complex when you add in things like 3D or shaders, but for this article, I'm only covering the required simple stuff. That said, I do make the assumption that the reader has had at least a few hours of XNA experience.

Our primary goal is to render virtual graffiti using XNA. This means we need to be able to draw a line. I started by creating a PNG file that would act as a “brush.” In XNA, these 2D graphics are also known as sprites. The brush sprite looks like this:

Now we can use XNA's SpriteBatch class to draw our brush. The first problem I had, though, was that most XNA tutorials show drawing the sprite, continue, clear the screen, draw the sprite, continue, etc. I needed to retain previous brush strokes, which means drawing onto an intermediate drawing surface (RenderTarget2D), then drawing that to the screen.

The next issue I had was that the line I was trying to draw was very broken. See, the laser detection code runs at a maximum 30 FPS (the limit of my web camera). If I moved the laser fast enough, the screen would just look like a bunch of random points were being drawn. I had to move the laser very slowly to make it appear like a line. I remember reading an excellent article detailing a project by Rick Barraza, which led me to a link to some popular algorithms for creating a line where your input is two, 2D points.

So, drawing a line required only a simple, two-step process of A) getting a new point from laser detection, and B) drawing a line from last_laser_coordinate to current_laser_coordinate. After putting that together, we can now produce some useful looking graffiti!

Adding Crazy Graffiti Effects

The excitement of drawing simple lines in XNA wore off pretty fast. After all, the GPU is capable of some pretty amazing things. What about drawing with fire? Fire isn't boring:

The fire effect is done using a method slightly similar to the solid color sprite method described earlier. However, since it uses a particle system, the fire effect is much more complex. Each particle has its own shader to control position and color. With the time constraints of this project, I had modified code from this XNA tutorial. There weren't many changes from the tutorial's code, but a big hurdle was that the particles took 3D coordinates instead of the 2D coordinates I needed to draw the graffiti. I found a small snippet to handle that, though I was informed by other XNA gurus that there is an easier way to accomplish this. If you are curious, this is what it looks like (and it's not for the faint of heart):

protected Vector3 ScreenPointToVector3(Point coords)
{
    Matrix viewMatrix = 
        Matrix.CreateTranslation(0, -25, 0) *
        Matrix.CreateRotationY(
            MathHelper.ToRadians(CameraRotation)) *
        Matrix.CreateRotationX(
            MathHelper.ToRadians(CameraArc)) *
        Matrix.CreateLookAt(
            new Vector3(0, 0, -CameraDistance),
            new Vector3(0, 0, 0), 
            Vector3.Up);

    float aspectRatio = 
        (float)m_game.GraphicsDevice.Viewport.Width /
            (float)m_game.GraphicsDevice.Viewport.Height;

    Matrix projectionMatrix = 
        Matrix.CreatePerspectiveFieldOfView(
            MathHelper.PiOver4,
            aspectRatio,
            1, 10000);

    Vector3 nearScreenPoint = new Vector3(coords.X, coords.Y, 0);
    Vector3 farScreenPoint = new Vector3(coords.X, coords.Y, 1);
    Vector3 nearWorldPoint = 
        m_game.GraphicsDevice.Viewport.Unproject(
            nearScreenPoint, 
            projectionMatrix, 
            viewMatrix, 
            Matrix.Identity);
    Vector3 farWorldPoint = 
        m_game.GraphicsDevice.Viewport.Unproject(
            farScreenPoint, 
            projectionMatrix, 
            viewMatrix, 
            Matrix.Identity);

    Vector3 direction = farWorldPoint - nearWorldPoint;

    float zFactor = -nearWorldPoint.Z / direction.Z;
    Vector3 zeroWorldPoint = nearWorldPoint + direction * zFactor;

    return zeroWorldPoint;
}

The End Result

Web-camera device selection:

Fine tuning the laser detection:

About Jeremiah

Jeremiah Morrill is a software developer and 2010 MVP living in Las Vegas, Nevada. He owns a software company called HJT, http://www.hjtcentral.com/, with a couple partners. There he focuses on multimedia and rich user interfaces with WPF and Silverlight. Jeremiah spends a lot of his free time learning, listening and helping others in the online development communities. 

Getting Started

I'll start with the Hardware and then move on to the main application and engines that run the robotics.

To get started, all you need are the parts and software listed above, and some basic DIY skills. I found my parts at many different places, one of the best of which was Trossen Robotics (which also has a great forum site). I found automotive relays and wiring harnesses at All Electronics website, cheap Power Wheels ($15) at garage sales, and additional parts at the local junk yard.

If your Power Wheels car is in need of repairs, check out the Modified Power Wheels website for more info.

The video below shows pictures I started taking on the first day—they continue all the way through the prototyping life cycle.

Hardware

Modifying the Cars

To modify the car, I removed all the existing controls from my Power Wheels Barbie Jeeps and wired their rear motors together. (Keep in mind that in order for the car to go forward or in reverse, the wires on ONE of the motors has to be reversed. Otherwise, when you connect the two red wires together and the two blue ones together and give it power, one wheel will spin forward while the other one spins backwards.)

Next, I attached the motors to a set of automotive relays, forming a DPDT switch. This was in turn connected to a Phidgets four relay board. Two of the Phidgets relays will control the transmission.

For the steering, I used the tracks from an electric car seat to move the tires from right to left. Any 12 volt electric car seat should work—you can get them at an auto salvage yard, usually at a reasonable price. You could also use an old cordless drill, as seen here.

Note that you'll have to modify your car for the steering unit. To do this, I fitted a 2x4 into the front section of the car. On the board, I screwed in the seat track, giving it something solid to sit on.

The wiring for the steering motor was the same as the transmission, except I needed to add limiting switches to keep the tires from going too far left or right. I tied these to the automotive relays. Then, I wired the relays for steering to the Phidgets 4 relay board. (See wiring diagram. Or, for more on automotive relay, see here.)

I had two different versions of the jeeps and my process was a little different each time, so you might have a little trial and error to find the right fit for the car.

The plastic and drywall screws work great to hold everything in place but you might have a few extra screw holes when you're finished. I call that “character”.

Also, relays and motors can cause EMI noise. For ways to control it, read this.

You can now drive the car forward, reverse, left and right. To test this, try running the Phidgets test program or use my code. For a Phidgets test, right click on the Phidgets item in the tray on your computer. Then, select the 004 device and right click to bring up a screen that lets you manually control the device.

Remember to NEVER turn on both relays to transmission or steering at same time, or you will blow your motors, Phidgets and possibly the USB port to your computer. You can turn on one from steering and one from transmission—just turn them off before you switch to the other relays. My program does all of this for you. (The Phidgets driver also does all this for you, but beware: it gives you total control, so you can turn all relays on at once. As mentioned, this would cause bad things to happen.)

Adding a Gun Turret

To control the gun, we'll use three more Phidgets devices: the 888 interface IO board, the voltage board, and dual relay daughter boards. The voltage board will tell the 888 board when it sees a voltage spike, which happens when one gun hits another. The dual relay board acts like a simple switch; it fires the gun and allows it to reload ammo.

To aim the gun and move it from right to left, we'll use the Phidgets servo controller. As a cheaper option, you could replace the laser tag guns with just about anything else. (In a prior version, for example, I used only a relay and was able to shoot water from a windshield washer pump by using the relay as a switch and turning the power to the pump on and off.) We now have our hardware in place.

The gun is mounted in a holster that can be turned by the servo. I used the “lazy Susan” concept, the same as what most people have in their houses. I made a wooden box that the gun fits in and mounted it on a ball bearing swivel. The servo is mounted directly below it, and everything is control from the Xbox controller (you can buy them from Sparkfun.com). It's now time to control the car with the computer.

Computers

I used Asus EeePCs models 904 and 1000HE, but any computer with XP or newer installed on it will work. You can pick up a used Netbook (a great and cheap option for robotics) from EBay for little to nothing—I recently bought one that had a 32GB SSD and the 1.6 GHz Atom processor for $250. If possible, get one with a shock-resistant SSD drive. The ones we used at PDC all had standard hard drives and worked fine, but you have to watch for hard hits, which can damage the hard drives.

Controller Application

First, I have to give credit Joel Ivory Johnson, whose article and sample will make understanding the controller code much easier. His sample is also great for testing functionality and making sure the drivers are working properly for the Xbox 360 controller.

The main controller app is a simple program: an action happens (a button pushed, joystick moved, etc). Then, a call is made to the proper method. Finally, the method fires off a message to its queue and goes back to waiting for the next action (fire and forget). I created two methods: “Drivecar” and “GunControl”. The names pretty much tell you what's going to happen.

In addition to the two main functions, there are two timer events. One controls the main loop; the other allows feedback to be given back to the main program. The feedback can come from any of the engines, or from the scoreboard. I use the feedback timer to supply the players' vibrations to their controllers when they get hit. I also use it for beginning and ending a game.

I used Microsoft message queue to send messages from the application to the different engines.

So to summarize: I have feedback, 888 IO interface, servo, and relay interface queues that are installed on each Netbook. The queues operate on their own; we'll discuss them more below.

I have 3 cars and 3 computers (you could use more or less). I can bring on more cars or switch the computers around to different cars. I do this by using the DNS name of the computer and syncing it up with a configuration file. The engines will pull all their configuration data in from this file. Below is an example of one of the nodes, along with the code I use to read the node:

<Car>    
    <carnumber>TimCar2</carnumber>
    <relaycar>FormatName:DIRECT=OS:timcar2\private$\relaycar</relaycar>
    <servocar>FormatName:DIRECT=OS:timcar2\private$\servocar</servocar>
    <interface888>FormatName:DIRECT=OS:timcar2\private$\interface888</interface888>
    <feedback>FormatName:DIRECT=OS:timcar2\private$\feedback</feedback>
    <ok2reload>Y</ok2reload>
    <relayserialnum>8694</relayserialnum>
    <serialnum888>30448</serialnum888>
    <servoserialnum>88630</servoserialnum>
    <scorecard>FormatName:DIRECT=OS:timcar3\private$\scorecard</scorecard>
    <scorecardnolimit>False</scorecardnolimit>
    <scorecardnolimittime>1800</scorecardnolimittime>
</Car>

Each node (Car) has a “Carnumber” that's equal to the DNS name of the computer. The other information you see is the location of the private queues, the serial numbers of the different Phidgets devices, and some additional configuration data on how the game operates. The file is in XML format and the values are read in with the following code:

ProjectUtils.Utilities x = new ProjectUtils.Utilities();

whatcar = System.Net.Dns.GetHostName();
scorecard = x.ReadXMLFile4CarElementValue("c:\\deploy\\carconfig.xml", whatcar, "scorecard");
relaycar1 = x.ReadXMLFile4CarElementValue("c:\\deploy\\carconfig.xml", whatcar, "relaycar");
servocar1 = x.ReadXMLFile4CarElementValue("c:\\deploy\\carconfig.xml", whatcar, "servocar");
interface888car1 = x.ReadXMLFile4CarElementValue("c:\\deploy\\carconfig.xml", whatcar, "interface888");
feedbackque1 = x.ReadXMLFile4CarElementValue("c:\\deploy\\carconfig.xml", whatcar, "feedback");

Another function of the controller program is to determine how many players (1 or 2) are attached to this receiver. If there are two players, player 1 will be the driver and player 2 will be the gunner. If there is only one player, he will need to press the “A” button to switch back and forth between the different modes of play, since it's not safe to drive and shoot at the same time.

if (this.gamePadState1.IsConnected == true)
{
    player1active = true;
    numberOfPlayers++;

    //what if only one player let them choose if they want to be in driver or
    // gunner mode
    if (this.gamePadState2.IsConnected == false)
    {
        if (!this.gamePadState1.Buttons.Equals(this.previousState1.Buttons))
        {
            if (this.gamePadState1.Buttons.A == Input.ButtonState.Pressed)
            {
                if (player1Driver == true)
                {
                    player1Driver = false;
                    lbT1Player1.Text = "Gunner";
                }
                else
                {
                    player1Driver = true;
                    lbT1Player1.Text = "Driver";
                }
            }

        }
    }

}
else
{
    lbT1Player1.Text = "Not Connected";
    player1active = false;
}

if (player1active == true)
{
    if (player1Driver == true)
    {
        lbT1Player1.Text = "Driver";
        DriveCar(gamePadState1, previousState1, 1);
        PlayRadio(gamePadState1, previousState1, 1);
    }
    else
    {
        lbT1Player1.Text = "Gunner";
        GunControl(gamePadState1, previousState1, 2);
    }
}

if (this.gamePadState2.IsConnected == true)
{
    player2active = true;
    numberOfPlayers++;
    GunControl(gamePadState2, previousState2, 2);
    lbT1Player2.Text = "Connected";
}
else
{
    lbT1Player2.Text = "Not Connected";
    player2active = false;
}

In XNA programming for the Xbox controller, there are previous and current states. For the most part I care only about the current state of the controller, but I do use the previous state to see if the button or joystick has moved between the last loop and the current loop. The loops happen every 100 milliseconds for the main loop (10 times a second, 1000 milliseconds = 1 second).

Below is the code for the “DriveCar” function. As you can see, it's pretty straightforward—I simply pass in the previous and current states of the game controller. For steering, I interrogate the state of the right joystick. If it's a different value than the last time we were here, I send a message to the “InterfaceIO” (004 Phidgets interface board) message queue, passing the current state value of the joystick. The drive engine will take the value and determine the action. The transmission is handled the same way, except that we check the left joystick.

private void DriveCar(GamePadState gameController, GamePadState prevState, int player)
{
    //either player 1 or 2 will send their current GamePadState
    int xStickCurrent;
    int xStickPrev;
    int yStickCurrent;
    int yStickPrev;
    string steerPos = "";

    if (allstop == false)
    {
        //Steering
        xStickCurrent = (int)((gameController.ThumbSticks.Right.X + 1.0f) * 100.0f / 2.0f);
        xStickPrev = (int)((prevState.ThumbSticks.Right.X + 1.0f) * 100.0f / 2.0f);

        steerPos = xStickCurrent.ToString();

        if (xStickCurrent != xStickPrev)
        {
            queueCount++;
            //6 = servo number , steerPos = joystick position
            listBox1.Items.Add("steering" + steerPos);
            qM.SendMsgNoTransaction(3, "3" + steerPos, relaycar1);
            xStickPrev = xStickCurrent;
        }

        //Transmission
        //0-49(backward) 51- 100(forward) 50 = Neutral

        yStickCurrent = (int)((gameController.ThumbSticks.Left.Y + 1.0f) * 100.0f / 2.0f);
        yStickPrev = (int)((prevState.ThumbSticks.Left.Y + 1.0f) * 100.0f / 2.0f);

        if (yStickCurrent != yStickPrev)
        {
            queueCount++;
            listBox1.Items.Add("transmission " + yStickCurrent.ToString());
            qM.SendMsgNoTransaction(3, "4" + yStickCurrent.ToString(), relaycar1);
            yStickPrev = yStickCurrent;
        }
    }
    else
    {
        //we are in all stop do not allow any sends to car...
        //if we have not sent all stop to relay engine do it..
        if (sentallstop == false)
        {
            sentallstop = true;
            //tell transmission to go to neutral
            qM.SendMsgNoTransaction(3, "450", relaycar1);
        }
    }
}

Each of the queue engines (feedback, drivetrain, 888interface) is set up pretty much the same way. The “Main” function sets up the Phidgets device it will control. It then goes into an endless loop until you cancel the program. In the loop, it checks the Message queue for any new messages and calls the proper function based on the content of the message. Then, it gives the processor back to the computer via the do events call while it waits for the next message.

Below is the “Main” function from the drivetrain queue engine. It sets itself up based on the configuration file and creates the events that the Phidgets devices require. The code then enters its loop and waits for messages to process.

static void Main(string[] args)
{
    whatcar = System.Net.Dns.GetHostName();
    relaycar = projectUtils.ReadXMLFile4CarElementValue("c:\\deploy\\carconfig.xml", whatcar, "relaycar");
    ioboardserialnum = projectUtils.ReadXMLFile4CarElementValue("c:\\deploy\\carconfig.xml", whatcar, "relayserialnum");

    //write to the console what is happening, useful for debugging
    Console.WriteLine("Configured Car number - " + whatcar + "\r\n");
    Console.WriteLine("Configured Relay serial number - " + ioboardserialnum + "\r\n");

    //Wiring up the Phidgets devices with their events
    ifKit = new InterfaceKit();

    ifKit.Attach += new AttachEventHandler(ifKit_Attach);
    ifKit.Detach += new DetachEventHandler(ifKit_Detach);
    ifKit.Error += new ErrorEventHandler(ifKit_Error);

    ifKit.InputChange += new InputChangeEventHandler(ifKit_InputChange);
    ifKit.OutputChange += new OutputChangeEventHandler(ifKit_OutputChange);
    ifKit.SensorChange += new SensorChangeEventHandler(ifKit_SensorChange);

    ifKit.open(int.Parse(ioboardserialnum));

    while (true)
    {
        try
        {
            // get the message from the message queue 
            o = qM.PullMsg(relaycar);

            //body will have for servo 1 to 7 rest of string is position to move too.
            if (o != null && o.QueMsgBody != "")
            {
                mycount++;
                Console.WriteLine("process body and count " + o.QueMsgBody + "  " + mycount.ToString() + "\r\n");
                inputDeviceNum = Int32.Parse(o.QueMsgBody.Substring(0, 1));
                msgMainBody = int.Parse(o.QueMsgBody.Substring(1));

                switch (inputDeviceNum)
                {
                    case 3:
                        steering(msgMainBody);
                        break;
                    case 4:
                        transmission(msgMainBody);
                        break;
                }
            }
            else
            {
                Console.WriteLine("null or 0 length queue message" + "\r\n");
            }

            Application.DoEvents();
            Thread.Sleep(100);
        }
        catch (Exception ex)
        {
            projectUtils.WriteEventToApplicationLog("PhidgetsIO", "Main -> " + ex.ToString());
        }
    }
}

This snippet of code is the “transmission” function, which allows the car to move forward, in reverse or stop. This is where I determine what action I need to do based on the joystick's position.

private static void transmission(int myPos)
{
    try
    {
        if (myPos < 20)
        {
            myMsg = "Moving transmission to => Reverse";
            currentSteerPos = "R";
        }
        else if (myPos > 80)
        {
            myMsg = "Moving transmission in Forward";
            currentSteerPos = "F";
        }
        // giving most range from the joystick to stop the car, being safe
        else
        {
            myMsg = "Moving Transmission to =>  Neutral";
            currentSteerPos = "N";
        }

        Console.WriteLine(myMsg + "\r\n");
        //first stop motor, then wait  and finally do new command.
       // we stop only long enough for the electricity to stop energising the relay
        //since we are turning both relays to off (false) that is the same as Neutral so we
        //do not need to check for it.

        if (ifKit.Attached == true)
        {
            //set relay 3 to not be engerized, relays start with 0 base count
            ifKit.outputs[2] = false;
            Thread.Sleep(20);
        }

        if (ifKit.Attached == true)
        {
            //set relay 3 to not be engerized, relays start with 0 base count
            ifKit.outputs[3] = false;
            Thread.Sleep(20);
        }

        if (currentSteerPos == "F")
        {
            if (ifKit.Attached == true)
            {
                // turn on relays to power motors forward
                ifKit.outputs[2] = true;
            }
        }
        else if (currentSteerPos == "R")
        {
            // turn on relays to power motors reverse
            if (ifKit.Attached == true)
            {
                ifKit.outputs[3] = true;
            }
        }
    }
    catch (Exception ex)
    {
        projectUtils.WriteEventToApplicationLog("PhidgesIO", "Transmission -> " + ex.ToString());
    }
}

Notes

First, remember to always turn off relays before changing direction, so you never have both relays running at the same time.

Also, there is more code in the “main” function (instead of in a timer routine) because of performance issues. When I created a timer and added all the code to the event, the processor showed like it was redlined at 100%. When I put the “do events” in the timer event everything worked fine, but it still looked like the process was redlined. However, when I moved everything into the “Main “ function and added a “do events”, everything worked fine and the processor dropped to about 8% usage—even with all of the engines running and the main program processing the Xbox controller commands.

Conclusion

This was a fun project that gave me a better understanding of robotics and C# functionality. Like I said in the beginning, there are many things you could do to make it better and even faster—I simply gave you a starting point. Questions to ponder: Why console apps and not Windows services? Why MSMQ and not WFC?

If you have any questions or thoughts, feel free to ask them here or over at my blog.

About The Author

Tim is an IT Director in the Enterprise Architect Group for Maritz, a sales and marketing services company. He has developed many systems in numerous languages over the years and is currently working with C#. In his off time he enjoys coming up with off the wall ideas and then seeing if he can make them happen. Tim's blog is finally getting started and can be seen at Waterhobo.com where he tries to explain them; he can be emailed at tbh726@gmail.com.

Internet Explorer 9

Arguably one of the bigger announcements from PDC, Steven Sinofsky gave attendees a first look at what’s coming in IE9 with a demo of an early build. The updated browser will support new web standards including HTML5 and CSS3 and will also have a faster JavaScript rendering engine. Sinofsky admitted that JavaScript performance in IE8 was much slower than other browsers and it’s clear that addressing this problem was a key goal for the IE9 team. A post on the IE blog shows a chart comparing the script performance on IE, Firefox, Chrome and Safari. Although still a test build, IE9 has narrowed the gap considerably when it comes to speed:

The new browser will also include “hardware accelerated rendering” which means it will now render graphics and text using the graphics card instead of the CPU. For the end user, this means that online images, videos, animations, and web fonts will be displayed faster, more clearly, and will use less CPU in the process of doing so. This is one of the better features of IE9 as it takes advantage of Direct2D and DirectWrite technologies to do something that today’s other browsers don’t – and it’s more useful than both Google's Native Client and Mozilla's WebGL for accelerated 3D graphics, said Dean Hachamovitch, IE’s GM.

Office 2010

At PDC, Office 2010 launched into beta along with SharePoint Server 2010, Visio 2010, Project 2010 and Office Web Apps. Office has been given a new look with updated logos and icons, but the most exciting development is the Outlook Social Connector. With this tool, you can track conversations and stay up-to-date with everyone you communicate with via email without having to switch over to another program or website.

Likely inspired by the demands for more social inbox experiences provided by plugins like Xobni as well as third-party services like Gist, the Social Connector will also focus on social network and email integration. As with Xobni, the connector tracks your communication history with your email contacts, your upcoming meetings, and it helps you easily find attachments they may have sent. It also offers activity feeds for each person based on their actions on both business and consumer social networks, including SharePoint 2010’s new social features and Windows Live. 

The first consumer network to support the new feature is LinkedIn, the professional business networking site. With the LinkedIn integration, you’ll be able to track your connections, email them, send invites, and more.

The Social Connector is available now in the Office 2010 beta and the LinkedIn integration will go live early next year.

Silverlight 4

Another major announcement was the developer release of the Silverlight 4 public beta. The updated platform includes a number of new features like webcam and microphone support for sharing audio and video in Silverlight apps, performance improvements that allow it to run 200% faster than Silverlight 3, support for Google Chrome, Deep Zoom enhancements, multi-touch support, and the ability to bring data into the app via copy/paste or drag-and-drop. For example, you could now drag an Office document into a Silverlight application, if desired.

To show off the new capabilities, a Silverlight Facebook app was demonstrated (TechCrunch has the screenshots).  In the app, cycling through the photos was a much faster experience that what it would be in the browser.

Silverlight 4 is a developer release only so no end-user runtime is being provided at this time.

Pivot

Pivot is a new Microsoft Live Labs experience that lets you interact with “massive amounts of data in ways that are powerful, informative, and fun.” Essentially, it’s a visualization tool for organizing datasets to discover new patterns and insights. The tool, built in SeaDragon and powered by Silverlight, does the visualization over the web. In other words, it’s streaming the data, not caching it locally to your hard drive.

In Pivot, datasets are organized as collections which are displayed using thumbnail images. The collections consist of objects that share some common attributes. In Pivot, you can analyze all these objects in a broader context. For example, as the video explains on Pivot’s homepage, they used Pivot to look at all of social lending organization Kiva’s loans and sort them by loan type.

Another example of Pivot in action is Brandon Watson’s Crunchbase Viewer which allows you to sort through the massive amounts of data stored in the online database about internet startups.

In order to use Pivot, you need an invite. You can request one here.

The biggest news to come out of the keynote was the announcement that Azure will launch into production on January 1st, but customers will get the first month of service free. However, prior to its public launch, a few companies are already using Azure now. During the keynote, some of them came on stage to discuss how. This group included some big names like WordPress, Domino’s Pizza, and the Cheezburger Network (yes, the blog empire built from LOLcats).

Matt Mullenwag of Automattic, the company behind the open-source blogging platform WordPress, showed off how Azure powers their service, taking away the stress related to massive traffic spikes. And yes, that was a downright geek-tastic way of demonstrating how Azure works with open source technologies. The recent release of the SDK’s for PHP, Ruby, Java and Eclipse further highlights how Windows Azure extends beyond Windows technologies.  

Similarly, the ICanHazCheezburger network is launching a new site on Azure called www.oddlyspecific.com. The site, devoted to funny signs, will also use Azure to help balance the massive traffic spikes common with its virally shared properties.

Another big name from outside the web world moving to Azure is Domino's Pizza who uses the platform to manage their ordering system. The company says it will be especially helpful on Super Bowl Sunday when ordering peaks.

Kelly Blue Book (KBB), will also be moving to Azure, allowing them to close a second data center kept online mainly for failover reasons. With Azure’s ability to provide extra computing power when necessary, the company says the extra data center will no longer be needed.

Even Vivek Kundra, the U.S. government’s CIO made an appearance to discuss open-development efforts, specifically a project code-named “Dallas” which is powered by Windows Azure and SQL Azure. This “data as a service” offering is an open marketplace for data. The data will be available for purchase at a site called “Pinpoint” and includes data from NASA, the AP, National Geographic, data.gov, and more. Kundra also said that he was looking forward to the “thousands of applications that are going to be created,” and after everything we heard about Azure’s power, we are too.

Drinktendr

Ever get tired of pouring your own drink?  Have someone get upset at you since it was too strong or too weak?  Well, why not have a machine pour you the perfect beverage every time!  Drinktendr uses Linq2Sql and SQL Server to know what drinks it can make with what is on hand.  Combine this with WPF; the end user is given a top end experience.

Mind Blaster

With aliens threatening to invade Earth, it's your job to travel into outer space and destroy the alien threat…with your mind!  Wearing a brainwave detecting headset, coupled with head tracking hardware using a wiimote, use only your brain to destroy alien ships before they destroy you and the rest of humanity.

Laser Graffiti

Putting graffiti on something is not a very nice thing to do but what if with a flick of a switch, it was gone.  With a projector, an off the shelf webcam and a laser pointer, you can do just that.  Aim the laser at the building and start drawing.  Turn off the laser and it all goes away!  Using WPF and XNA, we can apply a variety of effects including fire, paint, and various particles.  This project was influenced by the Graffiti Research Lab.

Augmented Reality

We'll be showing off two AR games.  ARroller and AR Domino Knockdown. ARroller is a single-player “marble game” experienced through a 3DOF-tracked video–see-through head-worn display. The player holds a tracked board on which a virtual marble must be manipulated through a maze of obstacles by tilting and moving the board. AR Domino Knockdown is a two-player first-person-shooter. Players hold 6DOF-tracked UMPCs through which they fire virtual balls at a configuration of virtual dominos on a shared table.

Wi-Fi Warthogs

Go big or go home.  After seeing Halo, we decided we had to make some remote control wart hogs to play laser tag with.  Using Xbox controllers, a wireless network, and Power Wheel cars, we've made a game of laser tag like no other.

In a speedy 10 minutes, Mike and Jennifer cram in an update about PDC content, Birds-of-a-Feather, hotel options, the PDC attendee directory, and how to win big bucks and a free trip to the PDC by entering the www.Code7Contest.com.  Phew, that’s a mouthful!  Don’t forget to email pdc09@microsoft.com with your questions and feedback, and maybe you’ll get a shout out on the show.

Presented by http://tr.im/MarkCarroll and http://tr.im/MikeZeff
 
Using computers in the cloud can make a great deal of sense. Instead of provisioning part or all of your infrastructure you can instead exploit Internet-accessible servers and let others worry about keeping systems up to scratch. But why just stop at the cloud? Some applications may have their code and data both operating in the cloud, others may run inside an organisation storing data in the cloud or relying on other cloud infrastructure services. Applications that run on desktops and mobile devices can use services in the cloud to synchronise information across many systems or in other ways. Whatever approach makes sense exploiting and extending the cloud’s capabilities can open up new choices for applications hosting, storage and interoperability.

A primeira vez que vi essa demonstração em julho eu fiquei muito empolgado. Há tempos muita gente cobra da Microsoft uma versão do Office para rodar na Web. Já existia o Office Live Workspace, que é um espaço para armazenamento de documentos e colaboração no estilo do Sharepoint. Para essa finalidade, o Office Live Workspace funciona muito bem. Porém, a maioria queria ver algo que permitisse a edição de documentos online e não somente a visualização que o Office Live Workspace permite.

Bom, hoje no PDC a Microsoft revelou que a próxima versão do Office permitirá a edição de documentos Word, Excel, PowerPoint e OneNote na Internet através do Office Web Applications. Não só isso, ele terá toda a riqueza do Office 2007 como:

• Faixa de opções (ribbon)
• Pre-visualização das alterações
• Formatação condicional
• Publicação para a Web via iframe
• Edição colaborativa em tempo real

Visualização do Word Online

Edição no Word Online

Visualização do OneNote Online

Edição do OneNote Online

São somente algumas das novidades. O Office Online utiliza a plataforma Live Mesh para sincronizar os dados e informações em tempo real. Por exemplo, se você publicar uma planilha ou gráfico Excel no seu blog e alterar esse gráfico, ele será automaticamente atualizado no seu blog também. E essa mesma plataforma permite a edição colaborativa em tempo real via Web.

Essa era a surpresa do PDC que eu disse que ninguém esperava. Disponibilidade do Office Web Applications será mais para o final desse ano em forma de beta. Quem quiser utilizar terá que se cadastrar no Office Live Workspace. O serviço será gratuito para usuários finais e terá propagandas. Espero que tenham gostado!

Os principais componentes da Plataforma de Serviços Azure são:

• Windows Azure – hospedagem e gestão de aplicativos, armazenamento escalável, computação e rede nas nuvens;
• Microsoft SQL Services – permite uma gama grande de serviços de banco de dados e relatórios;
• Microsoft .NET Services – implementação de conceitos conhecidos do .NET Framework voltada à serviços;
• Live Services – permite uma forma consistente para usuários armazenar, compartilhar e sincronizar documentos, fotos, arquivos e informações através de PCs, celulares, aplicativos e Web sites;
• Microsoft Sharepoint e Dynamics CRM Services – voltado a cenários empresariais permitindo armazenamento de conteúdo, colaboração e rápido desenvolvimento de soluções nas nuvens.

Saiba todos os detalhes em www.azure.com.

Bom, após essa grande inovação, eles apresentaram um ano atrás a segunda grande inovação. Todo cliente tem direito de assistir filmes e seriados da coleção da Netflix pela Web de graça. Não toda a coleção está disponível no momento (são 20.000 títulos no momento) mas a cada mês eles disponibilizam mais títulos para seus clientes.

O grande porém era que isso só estava disponível para clientes com Windows XP e Vista. Mas hoje eles anunciaram o mesmo serviço para usuários de Mac OSX. Isso só foi possível graças ao Silverlight por sua natureza de ser multi-plataforma e multi-browser. Hoje Silverlight 2.0 já conta com uma tecnologia DRM chamada Play Ready que permite entregar conteúdo com DRM para Mac, Windows e Linux e Internet Explorer, Safari e Firefox. E não por acaso o anúncio foi feito hoje, o primeiro dia do Microsoft Professional Developers Conference 2008.