Coding4Fun

If it is broken, fix it

Coding4Fun — Fri, 05 Feb 2010 22:49:41 GMT

Our own Brian Peek chats on how he fixed a leaky handle driver for the Acer 1420P (PDC build) laptop.

Brian used a some free tools to figure out why the one of the tablet’s processes was growing at 10 handles second and what to do about it. With the Process Explorer tool and IDA, he saw CreateFile was being called but never closed.

Brian has the source code and application up for download. He also goes more in depth on the his actual fix in his post on his blog.

ASP.Net server-side image resizing with WPF

Coding4Fun — Mon, 01 Feb 2010 23:42:09 GMT

Bertrand Le Roy shows off how to create dynamic images leveraging WPF’s image manipulation classes in an ASP.Net project instead of GDI+ classes to dramatically reduce creation time.

His prior post on this topic actually shows how to create them and why it is so fast. It also shows off different algorithms and their outputs with benchmarks. Some algorithms may produce great images but if they are slow, in certain cases, they can’t be used.

Bertrand’s method does work in a Medium Trust environment but be aware of how your processing stuff. This may not be a solution for you.

[via This week on Channel 9]

Making an Ocean with XNA

Coding4Fun — Wed, 27 Jan 2010 19:00:45 GMT

In this article, Louis Ingenthron will show you how to create a simple endless ocean for an XNA C# game.

Louis Ingenthron
FV Productions

Code It: http://xnaocean.codeplex.com/

Difficulty: Intermediate
Time Required: 1-4 hours
Cost: FREE
Software Needed: Visual C# Express, .NET Framework 3.5, XNA Game Studio 3.1
Hardware: Windows PC

Introduction

Every game needs boundaries, such as a window separating the player from space or a brick wall. When I first played Splinter Cell: Double Agent's Cozumel Cruise level, I spent a good 5 minutes just looking at the ocean that kept the player in bounds. It was a beautiful sunset with waves moving across the ocean endlessly outward... and it was neat.

When I was tasked with creating a great ocean for a Caribbean pirate game, I knew it had to look great, like Splinter Cell’s. Too many games, especially indie games, just put a cheap texture or two on a blue quad. But in my opinion, having a great looking boundary like an ocean can really tie your environment together and add a layer of polish.

Now, just to clarify: we aren't going for the ocean in Crysis here. We want something that looks good and seems to be endless, so most of our work will be in the DirectX 9 Shaders. We will be using C# and XNA to build a project around it (XNA is fantastic for rapid development and tech demos, as well as its full Indie Games Distribution system).

Getting Started

Let's take a look at the base project. You should be able to compile and run it on the spot. When you get in, you will be able to turn the camera with the mouse and move with WASD (or use the first gamepad with standard FPS controls if you converted to run on Xbox360), but all that’s there is the skybox at an infinite distance away. I won't go into rendering skyboxes in this article because there are many articles about it already. But you should be familiar with the concept of Cube Maps, which are basically six square textures representing the six faces of a cube.

So, let's get right into the code. We’ll start with a big blue plane. Open up Ocean.cs. You will notice that we already have some code in here. We have some vertices set up in the Load() function and a vertex declaration created (Again, in this article I assume you have a basic understanding of 3D rendering). These vertices will create two triangles that make a very large XZ plane at Y=0. Since our ocean will be processed only in the pixel shader, the plane should be much larger than your far-clip plane set up in your projection matrix. So let's draw the plane. In the Ocean's Draw() function, add these lines:

Global.Graphics.VertexDeclaration = OceanVD;
Global.Graphics.DrawUserPrimitives<VertexPositionNormalTexture>
    (PrimitiveType.TriangleList, OceanVerts, 0, 2);

This code tells the graphics device what kind of vertex we are using, and tells it to draw two consecutive triangles. But XNA uses only Shaders; it doesn’t support fixed function.

Let's go over to our Solution Explorer. Right click on the Content project in our game project, and click Add -> New Item. Choose the "Effect File" template and name it OceanShader.fx. We are just testing to get the quads on there now, so we won't do much in this effect file yet. I cleaned up the pre-generated comments and changed the pixel shader return value to float4(0,0,1,1) to make it blue instead of red.

Now, let's go back to Ocean.cs. We need to add a new class variable for the shader. This is encompassed by the Microsoft.Xna.Framework.Graphics.Effect class. We add this to the top of the class:

// the ocean's required content
private Effect oceanEffect;

And we actually link that to our FX file in the load function with this:

// load the shader
oceanEffect = Content.Load<Effect>("OceanShader");

Now we just need to set the shader variables in the draw function and tell the shader to begin and end. Our draw function now looks like this:

public void Draw(GameTime gameTime, Camera cam, 
        TextureCube skyTexture, Matrix proj)
{
    // start the shader
    oceanEffect.Begin();
    oceanEffect.CurrentTechnique.Passes[0].Begin();

    // set the transforms
    oceanEffect.Parameters["World"].SetValue(Matrix.Identity);
    oceanEffect.Parameters["View"].SetValue(cam.GetViewMatrix());
    oceanEffect.Parameters["Projection"].SetValue(proj);

    oceanEffect.CommitChanges();

    // draw our geometry
    Global.Graphics.VertexDeclaration = OceanVD;
    Global.Graphics.DrawUserPrimitives<VertexPositionNormalTexture>
        (PrimitiveType.TriangleList, OceanVerts, 0, 2);

    // and we're done!
    oceanEffect.CurrentTechnique.Passes[0].End();
    oceanEffect.End();
}

Before we draw, we must first begin an Effect and an EffectPass. Since we only have one pass in our shader, we can just begin the first one. Next, we set the Transform matrices defined in the shader (Read here for more information on the transform matrices). Then we tell the Effect to CommitChanges(), which basically flushes the parameter changes down the tube to the graphics card so we can draw. Now we see our old code to draw the plane. Finally, we end the EffectPass and the Effect. The program should run now, with a big blue plane where your ocean is.

Skymap Reflections

One of the best ways to make water look really neat is to add reflection. Ever seen a snow-covered mountain reflected on the surface of a lake? It’s gorgeous. Let's make our ocean reflect the sky. Go back to the OceanShader.fx file. This is where we will do the majority of our work. We need to give the shader the sky cubemap. Add this parameter to the top of the FX file:

HLSL

textureCUBE cubeTex;
samplerCUBE CubeTextureSampler = sampler_state
{
    Texture = <cubeTex>;
    MinFilter = anisotropic;
    MagFilter = anisotropic;
    MipFilter = anisotropic;
    AddressU = wrap;
    AddressV = wrap;
};

Next, we need to replace the Vertex structures with ones that match the actual vertices. They should look something like this:

HLSL

struct VertexShaderInput
{
    float3 Position            : POSITION0;
    float3 normal              : NORMAL0;
    float2 texCoord            : TEXCOORD0;
};

struct VertexShaderOutput
{
    float4 Position            : POSITION0;
    float2 texCoord            : TEXCOORD0;
    float3 worldPos         : TEXCOORD1;
};

We’ve now added two variables. The texCoord is pretty simple. We just pass it along (and multiply it). The worldPos is already calculated for us, so we can just assign it. Since it’s an ocean, we can just assume that the normal vector is straight up (why would we have a slanted ocean?). Our vertex shader should look like this:

HLSL

VertexShaderOutput output;

float4 worldPosition = mul(float4(input.Position,1), World);
float4 viewPosition = mul(worldPosition, View);
output.Position = mul(viewPosition, Projection);
    
output.texCoord = input.texCoord*100;
output.worldPos = worldPosition.xyz;

return output;

To do reflections, we need one more variable. A reflection off a surface requires a source vector and a surface normal vector. We can create our source vector by subtracting the camera position from the input's world position. To get the camera position, we could extract it from the View Matrix, but that's a pain. Instead, we’ll just add a float3 variable to the top of our FX file like so:

HLSL

float3 EyePos;

Now we update our pixel shader function:

HLSL

float3 diffuseColor = float4(0,0,1,1);
float3 normal = float3(0,1,0);
float3 cubeTexCoords = reflect(input.worldPos-EyePos,normal);
float3 cubeTex = texCUBE(CubeTextureSampler,cubeTexCoords).rgb;

return float4((cubeTex*0.8)+(diffuseColor*0.2),1);

So what is this actually doing? First we set up the diffuseColor, which is the color of the ocean itself, blue, which keeps it from looking like a big mirror. Next we assume the normal is straight up (We'll change this later). Then we need to get the texture coordinates for the skymap. We will reflect the vector from the eye off of the surface normal. Cubemaps take 3-component vectors, and don't even need them to be normalized, so that's all we need there. Then we use those coordinates and actually store the texture lookup's RGB values (what sky has an alpha?). Finally, we combine 80% of the reflected sky color with 20% of the diffuse color. Can we run it now? Well, no. We defined those variables up top, but never set them. Let's go back to the Ocean.cs and add in some more parameter mutators:

oceanEffect.Parameters["EyePos"].SetValue(cam.Position);
// set the sky texture
oceanEffect.Parameters["cubeTex"].SetValue(skyTexture);

Now we can run it! You should see a big flat body of blue water that reflects the sky. Cool, huh? But it’s not very watery yet, is it?

Normal Mapping

Let's add some chop to the surface. Four normal maps are already be included in the Content project, so we just need to add a Texture2D array to our Ocean class and load in these textures. We'll call the texture array OceanNormalMaps:

private Texture2D[] OceanNormalMaps;

And load them in the Load() function like this:

// load the normal maps
OceanNormalMaps = new Texture2D[4];
for (int i = 0; i < 4; i++)
    OceanNormalMaps[i] = Content.Load<Texture2D>("Ocean" + (i + 1) + "_N");

What are we going to do with these textures? It's simple really: we'll lerp between them. Switch to the FX file and add two new texture registers (we'll only be lerping between two at any given time) and a float for the actual lerping value:

HLSL

float textureLerp;

texture2D normalTex;
sampler2D NormalTextureSampler = sampler_state
{
    Texture = <normalTex>;
    MinFilter = anisotropic;
    MagFilter = anisotropic;
    MipFilter = anisotropic;
    AddressU = wrap;
    AddressV = wrap;
};

texture2D normalTex2;
sampler2D NormalTextureSampler2 = sampler_state
{
    Texture = <normalTex2>;
    MinFilter = anisotropic;
    MagFilter = anisotropic;
    MipFilter = anisotropic;
    AddressU = wrap;
    AddressV = wrap;
};

Next, we change our pixel shader code:

HLSL

float3 diffuseColor = float4(0,0,1,1);
    
float4 normalTexture1 = tex2D(NormalTextureSampler, input.texCoord);
float4 normalTexture2 = tex2D(NormalTextureSampler2, input.texCoord);
float4 normalTexture = (textureLerp*normalTexture1)+
            ((1-textureLerp)*normalTexture2);
    
float3 normal = ((normalTexture)*2)-1;
normal.xyz = normal.xzy;
normal = normalize(normal);
    
float3 cubeTexCoords = reflect(input.worldPos-EyePos,normal);
    
float3 cubeTex = texCUBE(CubeTextureSampler,cubeTexCoords).rgb;
    
return float4((cubeTex*0.8)+(diffuseColor*0.2),1);

Alright, let's take a look at this. The first new thing we do is sample the new normal maps and lerp between them with the value declared earlier. Nothing too complex there. But then we need to convert the RGB value into a normal. You'll notice that we take the RGB, multiply by 2 and subtract by one. This simply takes the compressed RGB [0:1] value and converts it to [-1:1] for a full range of normals. The next line re-orders the normal's components. This is because the normal map is traditionally on the XY plane, but our ocean is on the XZ plane—so we swap the Y and Z components. Finally, we normalize our normal. Always normalize your normals! Everything after that is the same as before. Let's go set these variables we defined and get this thing working. Go back to Ocean.cs and add this code to the draw:

// choose and set the ocean textures
int oceanTexIndex = ((int)(gameTime.TotalGameTime.TotalSeconds) % 4);
oceanEffect.Parameters["normalTex"].SetValue(
    OceanNormalMaps[(oceanTexIndex + 1) % 4]);

oceanEffect.Parameters["normalTex2"].SetValue(
    OceanNormalMaps[(oceanTexIndex) % 4]);

oceanEffect.Parameters["textureLerp"].SetValue(
    (((((float)gameTime.TotalGameTime.TotalSeconds) - 
    (int)(gameTime.TotalGameTime.TotalSeconds)) * 2 - 1) * 0.5f) 
    + 0.5f);

You can do the math on this if you want, but basically it just cycles through the four textures and sets the lerp value so it’s a continuous shift. After all that, you should have an interesting image when you run the program!

Animate and Blend

Now we have something that resembles water. But when was the last time you saw water that just moved up and down—especially in the ocean? Let's animate this a bit! The first thing we’ll do is make the texture coordinates scroll based on time. Let's add a time float to the top of the FX file:

HLSL

float time = 0;

Next, let's scroll the texture coordinates in the normal map lookup:

HLSL

float4 normalTexture1 = tex2D(NormalTextureSampler, 
    input.texCoord+float2(time,time));
float4 normalTexture2 = tex2D(NormalTextureSampler2, 
    input.texCoord+float2(time,time));

Now, simply set the time parameter in the Ocean.cs's Draw():

// set the time used for moving waves
oceanEffect.Parameters["time"].SetValue(
    (float)gameTime.TotalGameTime.TotalSeconds * 0.02f);

Your water should be moving now if you run it.

There is one more enhancement we can do. What's better than having one moving surface? How about two? It's basically parallax normal mapping. We will change our pixel shader code to look like this:

HLSL

float3 diffuseColor = float4(0,0,1,1);
    
float4 normalTexture1 = tex2D(NormalTextureSampler, 
    input.texCoord*0.1+float2(time,time));

float4 normalTexture2 = tex2D(NormalTextureSampler2, 
    input.texCoord*0.1+float2(time,time));

float4 normalTexture = (textureLerp*normalTexture1) +
    ((1-textureLerp)*normalTexture2);

float4 normalTexture3 = tex2D(NormalTextureSampler, 
    input.texCoord*2+float2(-time,-time*2));

float4 normalTexture4 = tex2D(NormalTextureSampler2, 
    input.texCoord*2+float2(-time,-time*2));

float4 normalTextureDetail = (textureLerp*normalTexture3) +
    ((1-textureLerp)*normalTexture4);
    
float3 normal = (((0.5*normalTexture) + 
    (0.5*normalTextureDetail))*2) - 1;

normal.xyz = normal.xzy;
normal = normalize(normal);
    
float3 cubeTexCoords = reflect(input.worldPos-EyePos,normal);
    
float3 cubeTex = texCUBE(CubeTextureSampler,cubeTexCoords).rgb;
    
return float4((cubeTex*0.8)+(diffuseColor*0.2),1);

What we did here is add two separate, lerping texture coordinates together. The 1 and 2 have been scaled by 0.1, making the waves much larger. The 3 and 4 lookups are scaled by 2 so they are much smaller, and move much faster in the opposite direction. This makes it look like the ocean has an overall current and some smaller waves simulating wind. The pixels are then combined before being converted to normals. Go ahead and run it. You should see your nice, new ocean!

Conclusion

And there you have it: a nice, infinite ocean! Since the majority of the work is done in the pixel shader, it will go on to the very end of the depth buffer and tile infinitely. Also, this is best when you are only looking out at it. It becomes somewhat apparent to the user if you are looking at the level on the ocean and only the sky, not the level, reflects properly. You may also notice that the ocean looks a bit cartoony in our example, but the good news is that this is merely an effect of the skybox being done in a soft pastel style. A more realistic skybox means a more realistic ocean.

I'm looking forward to seeing how people use this effect! If you use it, please send me an email with a screenshot.

About The Author

Louis Ingenthron is a Game Developer in Orlando, FL. He works on commercial Console and PC titles, but runs his own Indie Games company, FV Productions, on the side. He is best known for his open source XNA rhythm game Unsigned and specializes in real-time Graphics programming. He has been working with XNA since the 2.0 Beta and with .NET C# for just as long. He is also familiar with several other development languages, such as C, C++, and Java. Occasionally, he can even be found doing web development and Flash. Louis also writes for MSDN's Coding4Fun website, contributing articles on a monthly basis.

Missile Launchers with F#

Coding4Fun — Mon, 25 Jan 2010 17:48:56 GMT

Chris Smith had a talk at the CodeMash conference in January 2010 titled “Being an Evil Genius with F# and .NET”. Chris created a post about his talk and doing Computer Vision, Speech Recognition, and shooting missiles at people all with F#!

Here is a bit of his speech recognition code using the System.Speech.dll:

let recognizerEvent = getWordRecognizer()

// Main handler - convert spoken text into RL commands
let handleWord spokenText =
    printfn "Recognized Word: %s" spokenText
    let action = 
        match spokenText with
        | "up"  // Has a hard time recognizing this :(
        | "north" -> MoveUp(20)
        | "down"  -> MoveDown(20)
        | "left"  -> MoveLeft(20)
        | "right" -> MoveRight(20)

        | "fire"  -> Fire

        | _ -> NoOp
        
    performAction rocketLauncher action |> ignore

// Exit handler - specifically look for exit/quit
let terminateLoop = ref false
let terminateLoopHandler = function | "exit" 
                                    | "quit" -> terminateLoop := true
                                    | _      -> ()

// Hook up event handlers
recognizerEvent.Add(handleWord)
recognizerEvent.Add(terminateLoopHandler)

while terminateLoop.Value = false do
    System.Threading.Thread.Yield() |> ignore
()

Chris happily provided the source code as well, RocketLauncher_v1.0.zip.

Creating torn images

Coding4Fun — Wed, 20 Jan 2010 19:28:04 GMT

Adam Kinney did a pretty neat port of a flash application that creates an effect that gives an image like it was torn and crumpled up in Silverlight using the WriteableBitmapEx.

Blitting is the act of blending multiple images together. More about the BLIT operation can be found at Wikipedia.

Adam used the Blit method with different blend modes to achieve the effect from the standard image. With masking, alpha blending, and the multiply mode combined with a few masks and textures, he was able start with a standard image and give it that “pulled out of my pocket” effect.

The WriteableBitmapEx team over at http://writeablebitmapex.codeplex.com/ really did a great job with their library too!

Wi-Fi Warthogs

Coding4Fun — Tue, 19 Jan 2010 01:55:14 GMT

If you were at PDC09, you might have played “WI-FI Warthogs”, a computer robotics Laser Tag Game that uses the Xbox 360 controller to remotely control Power Wheels vehicles. In this article, I’ll tell you how to build your very own WI-FI Warthogs game, from start to finish.

Tim Higgins
Waterhobo.com

Source Code: Download

Difficulty: Intermediate
Time Required: 50 to 100 hours
Cost: $350+
Software: XNA to 360 example, Phidgets Libraries, Visual C# Express
Hardware: 1 motorized vehicle (Power Wheel), Netbook/Laptop, Phidgets devices , Xbox 360 controller with PC receiver

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.

Want Windows 7 Sensors that are Arduino powered?

Coding4Fun — Fri, 15 Jan 2010 18:06:29 GMT

Am I the only one warming up their soldering iron? I posted a bit ago on being able to do a Windows 7 sensor with a parallax board, but Brian Jepson (@bjepson) of MAKE and O’Reilly helped port that driver into a more generic driver that works with Arduino!

Right now there is one Arduino sketch in there from @skobalczyk; but they plan to add more soon.

Head over to http://win7sensorserial.codeplex.com to get the driver and how to do more!

Scanner access with WIA via WPF

Coding4Fun — Fri, 15 Jan 2010 17:00:00 GMT

Pete Brown has created an example of accessing a scanner with WIA via WPF. In the past we’ve chatted about going paperless with WIA and accessing a camera with it too, but Pete talks about how WIA the guts of it works and how to get an application to leverage it.

To find out more about WIA on top of Pete’s example, head over to MSDN’s section on it. http://msdn.microsoft.com/en-us/library/ms630368(VS.85).aspx

SSH that conversation

Coding4Fun — Wed, 13 Jan 2010 19:18:00 GMT

Tamir Gal has a Secure Shell (SSH) library for .Net. What is SSH you ask? SSH is a network protocol that allows data to be exchanged using a secure channel between two networked devices

SharpSSH allows you to read/write data and transfer files over SSH channels using an API similar to JSch's API. In addition, it provides some additional wrapper classes which offer even simpler abstraction for SSH communication.

SharpSSH is hosted on sourceforge, please check out its project page.

Windows 7: Federated Search

Coding4Fun — Mon, 11 Jan 2010 21:32:00 GMT

In this article, you'll learn how to use federated search in Windows 7 to easily locate items from various public and private sources directly from Windows Explorer.

Arian T. Kulp
http://www.ariankulp.com

Code It: Download
Try It: n/a
Difficulty: Intermediate
Time Required: 3 hours
Cost: Free!
Software Needed: Visual Studio 2008

Introduction

In this article, I've created a class file to encapsulate a federated search provider. This lets you use the new federated search feature of Windows 7. Here, you'll learn about:

Federated search
Serializing a class as an XML object
Creating a simple Silverlight project to expose it

What is Federated Search?

Windows 7 now lets you search web sites from Windows Explorer. This isn't a hugely-publicized feature, and it's not really accessible to developers (as far as I know), but it's useful for anyone.

Windows 7 federated search is built on the OpenSearch specification developed by Amazon A9. The search itself takes place by making a simple HTTP GET request for a given search term specified in a URL (http://example?search=TEST). The response is the web site's results, formatted as RSS or ATOM. Any site that offers search can choose to also make the results available in one of these supported formats. Applications like SharePoint, Exchange Server and even Sticky Notes included with Vista and Windows 7 offer this ability.

OpenSearch reduces the bandwidth needed for a typical search response and allows developers to create interesting applications with the results. Of course, one of these applications is the ability to display results directly in Windows Explorer, including the ability to sort by columns, copy and paste, and use the common search field. Some custom providers even support full integration with the Windows shell, such as drag-and-drop for copying entities or viewing additional properties (think Outlook, SharePoint, or images).

In order for Windows to add an OpenSearch provider, you need to provide a definition file in OSDX format. This format specifies human-readable descriptive information, along with necessary URL's and other parameters.

Generating OpenSearch Definition Files

The purpose of this project is to create OpenSearch definition files-that is, the OSDX files. These files are associated with Windows Explorer and add themselves to the Searches folder: C:\Users\{USER}\Searches.

This code does not actually perform any searches or integrate with Windows; it's not a proxy and it doesn't scrape web pages. In fact, it doesn't do anything except create the OSDX files to add to your system.

To create an OSDX file, you need to provide a URL to invoke and a name for the provider. A minimal file looks like this:

<?xml version="1.0" encoding="UTF-8"?>
<OpenSearchDescription xmlns="http://a9.com/-/spec/opensearch/1.1/">
  <ShortName>Bing</ShortName>
  <Description>Get Relevant Results &amp; Decide Faster. Bing Gets The Job Done!</Description>
  <Url type="application/rss+xml" template="http://www.bing.com/search?q={searchTerms}&amp;go=&amp;form=QBLH&amp;qs=n&amp;format=rss"/>
</OpenSearchDescription>

Once you find the right URL, use "{searchTerms}" to replace the term. There are also escape expressions for starting index ("{startIndex}"), result counts per page ("{count}"), and more. Note that Windows Explorer is very picky about using a provider file. If there is anything malformed in the XML (be sure to escape ampersands in URL's!) or if you are missing an Atom or RSS URL, then it will fail with no useful information:

To make this easier, I created a class, OpenSearchDefinition, with the right properties. The class and properties are marked up with XML attributes so it can be written out as well-formatted XML without any string concatenation.

It can be difficult to find sites that offer RSS search results, but fortunately there's another way. Bing searches the internet and can be scoped to a given site's content. Even better: you can request search results in RSS. Google provides RSS search results too, but you need to pre-configure your searches. Bing allows you to do this on-the-fly, as a parameter for any search.

Creating the Front-End

The OpenSearchDefinition class file does all of the work, and could be reused, but doesn't have a broad usage story. I created a Silverlight front-end to demonstrate one way of using it. An ASP.NET Web Form sits on the back-end and serves up the OSDX file based on URL parameters. The Silverlight application just provides a convenient way to enter those parameters.

The first tab is a way to create a provider for any site by using Bing. Remember that if you scope the search using the site parameter, Bing will return search results for only one site - effectively a site-level search.

The second tab is for building up an OSDX file using any site's RSS search URL. You can enter a custom name, description, and search URL. This is the best method for adding new search providers.

Though Bing can be used to search most sites, you won't be able to take advantage of all features a site has to offer.

Conclusion

Currently, very few site owners seem interested in offering syndicated search results-this may be because they're concerned about ads not being seen. But of course, if I perform a search and view the results, I'll likely end up on the site and see the ads anyway! So if you run a popular site and have a search feature (don't they all?) consider offering that little RSS/ATOM link next to results.

From the consumption point of view, it's really easy to create a search provider definition using the OSDX format. You could do it by hand, but this tool simplifies the process and shows off Silverlight, XML serialization, and a few other nifty features as a bonus!

The OpenSearchDefinition class file is ready to reuse. As with all Coding 4 Fun code, you can do whatever you want with it. Let me know if you find other uses for it!

Download the free Visual C# 2008 Express Edition so you can play with the code, or download the ASP.NET web site and give it a try.

Additional Information

Arian Kulp is a software developer living in Western Oregon. He creates samples, screencasts, demos, labs, and articles, he speaks at programming events, and he enjoys spending time with his family. Check out his homepage to contact him or learn more.

Video ambient lighting effects

Coding4Fun — Fri, 08 Jan 2010 19:12:30 GMT

Fun3 MD created a DIY version with an Arduino of the AtmoLight, which is a clone of the Philip Amblight system. Awesome job of leveraging a pre-existing technology instead of re-inventing the wheel.

RGB in, HLS out

Coding4Fun — Tue, 05 Jan 2010 02:03:07 GMT

David Veeneman wrote a neat little console application that will convert RGB colors to HLS (Hue-Luminance-Saturation) or HSB (Hue-Saturation-Brightness) over at Code Project.

One of the neat things David also did was show off using IValueConverter as well to do some of the conversion for you.

David did use an MSDN article as reference, if you want to see the sample, head over to http://msdn.microsoft.com/en-us/library/ms771620.aspx

Creating An Application With Full Plug-in Support

Coding4Fun — Mon, 28 Dec 2009 22:43:20 GMT

In this article, you’ll learn how to create an application with full plug-in support.

Arian T. Kulp
www.ariankulp.com

Project site: http://utilrunner.codeplex.com/
Code It: Downloads
Run It: Downloads

Difficulty: Intermediate
Time Required: 3 hours
Cost: Free!
Software Needed: Visual C# 2008 Express Edition or higher

Introduction

It’s been a number of months since I released the first version of my Utility Runner application. Utility Runner makes it possible to run system utilities with as little overhead as possible: Instead of lots of tray icons, numerous EXE’s, and the associated memory and startup time overhead, this application manages multiple utilities from one place.

To open this solution, you’ll need Visual Studio 2008 Express Edition (Visual C# or Visual Basic), at least. If you don’t have it yet, you should get it!

Working with MEF

Little has changed functionally from the last version of the application, beyond some refactoring that’s taken place since the new version of MEF was released. For one thing, the attribute for marking an export is no longer sealed, so you can now create a subclassed attribute that encompasses the export name and any other metadata included with it. Consumers can simply use your new custom attribute for a stronger-typed experience. In my case, I created a WpfServiceMetadata class. Read on for more information.

Managing Addins

My big challenge was figuring out how to implement an addin manager to support multiple utility addins, like in Firefox. MEF lets you easily mark what classes are addins and where they should fit into your overall code, but I wanted to take it further. I decided that my goals were:

The ability to load an addin through the UI
The ability to disable/enable addins
The ability to remove an addin

There are a number of ways to achieve these goals. Mine isn’t the ideal way, but it works pretty well nonetheless.

Loading Addins

Loading addins is mostly handled by the MEF Framework itself, but there is some manual work involved as well. I decided that instead of scanning a folder for DLL’s like in the first version, I’d take things a step further: I came up with a simple packaging format to contain the addin and its associated files.

The packaging format is simply a Zip file renamed with the .util extension. The file contains at least the DLL of the addin itself, but might also include associated libraries, images, sounds, or other resources. I toyed with creating a manifest file to help supply addin information that didn’t require class loading, but I kept it simple for now.

Before loading DLL’s with addins, the AddinManager class will scan the addins folder for .util files and unzip them to same-named folders. Each of these folders gets added to the list of folders in which MEF searches. The original file then gets deleted.

Adding an addin

An application that uses addins needs a way for users to add new ones. The easiest method would be to have the user just drag new .util files into the Addins folder, but this isn’t very user-friendly. I wanted to make it easy for a user to click something in the application to install an addin.

If the user clicks the Add New Addin From File button, they use a file browse button to locate the file. The application then copies that file to the Addins folder and notifies the user that it will be loaded on next startup. It would be great to load the addin immediately, and MEF supports that, but I decided to skip dynamic addin control for simplicity.

Instead of going through the dialog when loading an addin, it would be nice to support double-clicking. To do this, an association needs to be made from the .util extension to the executable. If you launch the executable with a file argument and it’s the right format, it will automatically copy it to the Addins folder. If an instance is already running, the new instance will just exit. Similarly, if you launch the executable when another instance is running, the existing instance will show itself and the new instance will exit.

It’s important to note that standard users don’t have write access to the Program Files folder. For this reason, addins need to be stored in the user’s local profile folder. System-level addins can be stored in the ProgramData folder. Addins could be in the user’s roaming profile folder, but I haven’t thought through all of that yet. (For example, if a user logs into different machines, an addin might not run on each system due to different hardware configurations.)

Disabling an addin

Disabling an addin should be a simple matter of renaming the addin folder. You can’t do this at runtime though, since the DLL’s are locked and loaded. As an alternative, I create a file (zero-length) with the same name and add the .disable extension to it. I check for this upon startup and before loading, and can handle it properly.

Enabling and removing addins are handled similarly, using .enable and .delete extensions on the zero-length files.

Creating Addins

To create an addin, you need to 1) implement the IWpfService interface, and 2) add the WpfServiceMetadata attribute with a name for your addin. From there, be sure to implement all the methods in the interface. The Start method is called at initialization (you shouldn’t take much time in the constructor), and Stop is called at the end, for cleanup. Any time you want to update the Status, be sure to raise the StatusChanged event.

[WpfServiceMetadata("SampleAddin")]
public class SampleAddinImpl : IWpfService
{
}

The final thing you’ll need to do is copy your addin DLL to a folder with your addin name, plus the .util extension (Yes, an extension on the folder name. I do this in Visual Studio with a post-build event. If you debug the application, it looks for an Addins folder under the current directory. When started normally (such as when installed) it uses the local user profile.

When you’re ready to distribute the addin, compress the DLL and any supporting files into the top-level of a ZIP file, then rename the .zip extension to .util. You can load this from the Addins page of the app settings, or manually move it to the MefUtilRuner\Addins folder in your local profile folder (c:\users\{USERNAME}\AppData):

TimedQueue

Message boxes, balloon help, status bars—these are all great ways to display a message to the user, but they all only show one string at a time. If you call it again before the reader has the chance to see it, it’s just gone. There are some nice message managers that make it easy to manage stacking alerts, but I decided to stick with the built-in balloon help provider, and just manage how often I send changes. It’s basically a buffered balloon provider that will only show messages every x number of seconds, regardless of how many attempts the application makes. To use it, simply add items to the collection. An event is raised whenever an item is available. If an item has exceeded the maximum time-to-live threshold, the users of the collection never see it.

// Repeat while there are items (one pulse may occur with several items ready)
while (item != null)
{
    // If this is an old item, no event is raised.  This could happen if
    // a process goes into a loop and dumps a large number in a very short
    // amount of time.  
    if (DateTime.Now.Subtract(item.TimeStamp).TotalMilliseconds < _maxTTL)
    {
        RaiseEvent(item.Item);
        Thread.Sleep(_interval);
    }

    item = default(ItemWrapper<T>);

    lock (_lock)
    {
        if( _items.Count > 0 )
            item = _items.Dequeue();
    }
}

The main window creates an instance of the TimedQueue class. Every time an addin wants to display a message, it’s added to the collection. When ItemAvailableEvent fires, it’s dispatched to the UI thread to be displayed. Dispatching prevents cross-threading issues between the background TimedQueue thread and the UI thread.

void statuses_ItemAvailableEvent(object sender,
    ItemAvailableEventArgs<StatusMessage> e)
{
    Dispatcher.BeginInvoke((ThreadStart)delegate() {
        StatusUpdatedHandler(e.Item); }
        , DispatcherPriority.Background);
}

Though this instance is being used for status messages, you can also use TimedQueue for other purposes, when you are willing to lose old messages. One example would be to throttle user input, such as a game that doesn’t want constant firing or jumping as fast as the user clicks a button.

Next Steps

There are a number of things that would be nice to have in this application. It would be good to allow utilities to extend the context menu to enable or disable something, or at least to jump straight to their configuration page.

Using ClickOnce to deploy utilities would also be nice since it’s so clean for the user, but there is a cost: ClickOnce is very strict about how applications can interact with the system. They are always per-user, and they live in “secret” folders. Developers can’t read or write to the hard drive except to protected storage (similar to the iPhone I suppose). I’m not sure if they are restricted in other ways, but it could cause a hardship.

It would also be nice if addins could be added at runtime. This is a fairly simple case, but I didn’t get to it yet. Furthermore, if you add, you might expect to enable/disable/remove at runtime too. Unfortunately, disabling and removing aren’t really possible. Sure, I could call Stop on a utility and remove it from the UI (and not call Start on it next time), but that’s not really disabled since it could still be running until the next restart. I couldn’t force it to die unless I used separate application domains, which I’m loath to do.

Finally, I’d really like to get an “app store” type of repository going. I imagine being able to publish utilities like Sidebar Gadgets or Windows Live Writer Plugins so users can browse, read information, and click-and-install. That could be a really great way to make the idea take off.

Conclusion

There are definitely some rough edges at this point, but it’s getting there. The source code is fully available and I’d be willing to give commit access to anyone interested in moving things forward. Just drop me a line!

About Arian

Arian Kulp is a software developer living in Western Oregon. He creates samples, screencasts, demos, labs, and articles; speaks at programming events; and enjoys spending time with his family.

Trace.Writing in your web applications

Coding4Fun — Fri, 25 Dec 2009 08:45:42 GMT

We’ve talked in the past about debugging your application but if you can’t attach a debugger to your website, why not use the ASP.Net Tracing? This acts very much like a Debug.WriteLine in a Windows application but instead you do Trace.Write.

Since this does have some memory ramifications, you’ll have to add in a line to your web.config file under the System.Web section.

<system.web> 
<!-- Add me! -->
    <trace enabled="true" mostRecent="true" pageOutput="true" requestLimit="20" />

Then you just go to your trace.axd file. So in an example where your application is in “WebSite1” and on your local development box, http://localhost/WebSite1/trace.axd would be where to get this information

IronRuby sketch up

Coding4Fun — Wed, 16 Dec 2009 18:20:18 GMT

Jimmy Schementi posted about his talk at RubyConf 2009 and talked about embedding IronRuby in another program. His goals were:

2D rendering surface with simple primitive shapes
Simple animation support – callbacks for each frame and each object on the canvas
User-loadable “macros” for drawing and animating

His outcome looks amazing! It is worth noting Jimmy is using Visual Studio 2010 beta 2 for the demo here. His blog states he hasn’t tried it in Visual Studio 2008.