Posts Tagged ‘multipoint’

WPF Wii Binding Properties: Infrared Data

2 Comments »

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.


The Trials and Travails of the Infrared Multipoint

4 Comments »

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 Multi-Point Tutorials, Part 1.5: WPF Visualization of Wii Data

22 Comments »

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

No Comments »

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”

Read the rest of this entry »


WPF multipoint and the Wii

No Comments »

I’ll get back to my listview posts soon, but I really wanted to share this:

Here’s something from the guys at Cynergy in which they’ve combined WPF with a Wii-mote hack to implement an on-the-cheap multipoint interface.

Pretty cool.


Follow me: matthiasshapiro