Archive for the ‘multipoint’ Category.

WPF Wii Binding Properties: Infrared Data

This is an extension of my previous post, WPF Wiimote Library (Now With Project Files!), which has links to the WPF Wiimote Binding Library project files as well as some information vital to getting you started in connecting your application to the Wiimote.

And now for the IR properties:

The Wiimote can track up to 4 infrared (IR) LEDs at a time. If I were a programmer, I would have created an IR LED enum with the following properties as part of each IR LED. But since I’m not, these properties can be accessed with the following convention: IR[#][propertyName]. Each IR LED has the following properties:

IR[#]RawPosition

Type: Point

Summary: The IR camera has a X,Y resolution of 1024, 768. This property will give you the raw X,Y position that the Wiimote is tracking this LED at.

Binding Usage Example:

<Grid Canvas.Left=”{Binding Source={StaticResource WiiData}, Path=”IR1RawPosition.X, Mode=OneWay}
Canvas.Top=”{Binding Source={StaticResource WiiData}, Path=”IR1RawPosition.Y, Mode=OneWay}/>

Additional Info: This will work best if your Canvas is the exact dimensions of the Wiimote camera (1024, 768). These properties are automatically converted to take into account the IsMultiPoint setting (described in the Miscellaneous Properties (coming soon)).

IR[#]Position

Type: Point

Summary: This is the X,Y ratio of the position of your IR LED. The best way to use this is in a multi-binding with the width and height of your target Canvas. Fortunately for you, I’ve added a converter that will help with this. Simply add the following code in your resources:

<Wii:VariableCanvasPointConverter x:Key=”VariableCanvasConverter/>

And follow the binding example below.

Binding Usage Example:

<Grid>
   <Canvas.Left>
      <MultiBinding Converter=”{StaticResource VariableCanvasConverter}>
         <Binding Source=”{StaticResource WiiData}Path=”IR1Position.XMode=”OneWay/>
         <Binding ElementName=”MyCanvasPath=”ActualWidthMode=”Default/>
      </MultiBinding>
   </Canvas.Left>
   <Canvas.Top>
      <MultiBinding Converter=”{StaticResource VariableCanvasConverter}>
         <Binding Source=”{StaticResource WiiData}Path=”IR1Position.YMode=”OneWay/>
         <Binding ElementName=”MyCanvasPath=”ActualHeightMode=”Default/>
      </MultiBinding>
   </Canvas.Top>
</Grid>

Additional Info: These properties are automatically converted to take into account the IsMultiPoint setting (described in the Miscellaneous Properties (coming soon)).

IR[#]Found

Type: boolean

Summary: This is a property that is “true” if the Wiimote can see the target LED and “false” if it cannot.

Binding Usage Example:

<Grid IsEnabled=”{Binding Source={StaticResource WiiData}, Path=IR2Found, Mode=OneWay}/>

Additional Info:  This property is also available for the midpoint between the first and second infrared light (MidPointFound) and for the target point (TargetFound) which displays a calculated position of where the Wiimote is being pointed.

IR[#]Size

Type: double

Summary: The Wiimote naturally picks up the size of the LED it is tracking. To get larger sizes  (which translates into better reliability) use a small cluster of LEDs (three should do the trick) rather than a single one.

Binding Usage Example:

<Grid Width=”{Binding Source={StaticResource WiiData}, Path=IR1Size, Mode=OneWay}/>

IsIR[#]Visible

Type: bool

Summary: This item is meant for two way binding. If you want a way to programmatically choose whether or not to show the item that is bound to your IR interface, use this property. It is most useful when used in conjunction with the BoolToVisibility Converter, which can be used by placing this XAML in your resources:

<BooleanToVisibilityConverter x:Key=”boolToVis/>

Binding Usage Example:

<Grid Visibility=”{Binding Source={StaticResource WiiData}, Path=IsIR3Visible, Mode=OneWay, Converter={StaticResource boolToVis}/>

<CheckBox IsChecked=”{Binding Source={StaticResource WiiData}, Path=IsIR3Visible, Mode=TwoWay}/>

Additional Info:  This is a great property to attach to a checkbox (as seen above) to allow user control over which items are to be shown.

In addition to the infrared lights, the WPF Wii library is set up to display two calculated points as well:

  • A midpoint between IR1 and IR2
  • A target point (based on the midpoint) which indicates where the Wiimote is being pointed.

These two calculated points still have the position properties listed above (TargetRawPosition, MidPoint RawPosition, TargetPosition, MidPointPosition) as well as the visibility booleans (IsTargetVisible and IsMidPointVisible) and the “found” boolean properties (MidPointFound and IsTargetPossible).

Of course, you can also play around with the items in Intellisense is also a great way to discover all the available properties.

WPF Wiimote Library (Now With Project Files!)

Now that we’ve successfully demoed the Wiimote visualizer in the Open Space at MIX 08 and shown off what we can do at the Show Off event, I need to be a responsible blogger and put the project up… files and all. I have, with Brian Peek’s permission, packaged his managed library in here as well. Please read and respect his licencing agreements.

WPF Wii Binding Library (dlls only) 

WPF Wii Binding Library (source)

 There are really two parts to the WPF Wiimote Visualizer. The first part is the WPF Wiimote Binding Library, which we’ll cover in this post (or at least make this post the hub of that information). The second part is the Visualizer program itself, which is basically just the WPF Wiimote Library bound to a bunch of XAML elements.

The WPF Wiimote Binding Library will allow simple binding between your Wiimote and your WPF application (I’ve got a whole post on that here). But let me extrapolate a little on what the library has to offer. I’ve seperated out the data into different posts to make it a little more digestible.

Infrared Data

Button Data (coming soon)

Misc Data (Rumble, Battery, Accelerometers) (coming soon)

Nunchuk Data (coming soon)

The Trials and Travails of the Infrared Multipoint

OK, I’ve been waiting to post more on the Wii multipoint for a while, but I’m been waiting to get some kind of mobile infrared light system working. If you’ve watched Johnny Lee’s video, you would get the impression that it’s a 1-2-3 easy a cake thing to do.

 You would be so wrong.

 So, first I tried to duplicate his infrared array. He is using 100 IR LEDs to project a flood of IR light that is then reflected back to the Wiimote screen using reflective tape.

Reflective Tape: Is not easy to find. At all. Go ahead and try it. 3M sells reflective tape, but none of the hardware stores in Salt Lake City had any. As a plus, they said they could have it on hand within two weeks.

Ebay is an option if (again) you don’t mind waiting two weeks to get something. But there are many kinds of reflective tape. Which one works best? We’ll get to that part.

Infrared Array: Johnny Lee gives no specs on his IR array, so I can’t speak to its efficacy. I built one with 96 high output IR LED’s. In addition to the LED’s (which are $2 per LED at Radio Shack and closer to 30 cents per LED at Mouser), I had to get a breadboard, batteries, a voltimiter, and some resistors.

IRArray

In the end, it didn’t work. The LEDs all lit up just fine, but they didn’t output anywhere near enough light to give a healthy reflection. Was this the light or the relfective tape I was using? We’ll get to that part.

Infrared Spotlight: I initially assumed it was the light. So I got my hands on a 1,000,000 candle power IR spotlight to solve that problem. Turned it on and… nothing. The Wiimote picked up the spotlight shining on my shirt, but it wouldn’t pick up the reflection off the tape. So is this a problem with the light or with the tape?

 I have no idea, but I can tell you that the tape is borderline useless with everything I’ve tried.

Maybe I’m using low power IR LED’s (1.3 volt, 100mA) or maybe I’m using the wrong kind of reflective tape (I tried both engineering grade and retroreflective daybright… whatever that means), but I have had zero success replicating Johnny Lee’s design.

My next step is going to be an attempt to mount IR LED’s directly into a pair of gloves, which is how the Cynergy demo was done. This was the solutions that I finally got that working… as you’ll see in some videos over the next couple days.

WPF Wii Multi-Point Tutorials, Part 2: Writing a Code-less Wiimote Program

 OK, I hope no one is using my last post as an example of what you should be doing when interfacing the Wiimote with WPF. Because it was completely hack-tastic.

 Instead, use my new WPF/Wii library. It uses the WPF INotifyPropertyChanged interface to act as an interface so that we can bind the Wiimote data directly to the XAML. More on that in a little bit, but first…

In this post, we’ll walk through creating a basic multi-point capable app that uses the Wiimote as an input device. What is really unique about this post is the fact that we’re going to do this in a way that requires absolutely no code whatsoever on your part.

That’s right. No code. At all. Zero knowledge of C# required.

Continue reading ‘WPF Wii Multi-Point Tutorials, Part 2: Writing a Code-less Wiimote Program’ »

WPF Multi-Point Tutorials, Part 1.5: WPF Visualization of Wii Data

Download WPF Wii Data Visualizer (App only, 355K)
Download WPF Wii Data Visualizer (Visual Studio 2008 Source, 676K)

Warning: The project will not run if your Wii controller isn’t connected to your computer.

Using the WPF Wii Data Visualizer (Video)

OK, now that we’ve gotten our Wii Controllers all hooked up to our computers, it’s time to take a look at the data we’re getting from it.

Over the weekend, I pieced together a little application that will help us visualize the incoming Wiimote data in a way that would help understand the raw data points a little better as well as help out as we head toward our ultimate goal of multi-point WPF application development. This is what I came up with.

WPFWiiDataVisualizer

Disclaimer: The source code at this point is a mess. While the interface is all done in XAML and is very WPF, the code-behind is a hacked together mish-mash. I will at some point go back and restructure the code-behind to take advantage of the INotifyPropertyChanged interface. When I do that, I’ll post on it and we’ll see another example of why WPF is so freaking cool.

WPF Multi-Point Tutorials, Part 1: Connecting the Wiimote Controller

OK, so I’ve taken note of multi-point WPF a couple times now (both times were in regards to Rick Barraza’s Cynergy demo) and I started noticing that people are really interested in this. So I decided to take some time to create a couple tutorials on creating multi-point interfaces in WPF.

A point of note: I am not a programmer. I am a designer. This means that whatever code I post will probably be a mess. But it also means that if I can make something work in WPF, anyone can.

The first question we need to address is how to pull multi-point interaction data into your system. You could, of course, buy one of these. I don’t have that kind of money, so I decided to try my hand at the poor man’s multi-point: the ever useful Wiimote controller for the Nintendo Wii.

In this post, we’ll go over how exactly to connect your Wii controller to your computer via Bluetooth. (I’m using Vista. Could be different for XP, but I haven’t tried.)

First, open up your Control Panel and double click on “Bluetooth Devices”

Continue reading ‘WPF Multi-Point Tutorials, Part 1: Connecting the Wiimote Controller’ »