I am still here however my PhD is taking up most of my time so I haven’t had much time to post much. However it will all be over soon and things will get back to normal.

Some major Wii updates on the way as I write them up for my thesis, I promise. For more up to date info check out my work site.

Update

If you are looking for Wii related info check out http://wiici.dyadica.net/journal. The site is still in development but its where I have been publishing of late.

This site is to become primarily a personal blog with non a Wii related focus etc. So please update your links accordingly.

Its scary when you think like an evil dictator, roll on courier and for those who cant wait, theres always the archos 9. You cant help be left with the thought that they just had to be 2nd!

In a contrast to the usual performance Dom took up the singing mantle to add a new flavor to the proceedings.

Check out the video:

For more videos of the gig visit my youTube channel. For more info on the band visit www.sheriff-fatman.co.uk

This is a very useful addition that allows for “singular” triggering so that you don’t have to rely on “flag checks” within the standard WiimoteState loop and thus allowing the Libary to do all the work!

Before we start, this instruction assumes you have previously completed the Areas Quad and Zone Instruction.

Start off by opening up the Events.cs file and add the following code below the public class WiimoteChangedEventArgs:

/// <summary>
/// Argument sent through the BalanceBoardStepEvent
/// </summary>
public class BalanceBoardStepEventArgs : EventArgs
{
/// <summary>
/// The current state of the Balance Board
/// </summary>
public BalanceBoardState BalanceBoard;

/// <summary>
/// The Type of trigger that activated the event
/// </summary>
public StepType StepType;

/// <summary>
/// Constructor
/// </summary>
/// <param name=”bb”>Wiimote Balance Board State</param>
/// <param name=”type”>Step trigger type: Standard/Damped Quad/Zone</param>
public BalanceBoardStepEventArgs(BalanceBoardState bb, StepType type)
{
BalanceBoard = bb;
StepType = type;
}
}

What we have done here is create a new class that provides access to two arguments:

1. BalanceBoardState
2. StepType

By passing BalanceBoardState we are provided direct access to all the relevant Balance Board calls that we would normally have via WiimoteState. The StepType argument provides us with a reference to the trigger that we can then use to filter/output a desired response etc.

To define StepType open up DataTypes.cs and add the following enum block below the BalanceBoardState struct:

/// <summary>
/// The type of Step Triggered
/// </summary>
[DataContract]
public enum StepType
{
/// <summary>
/// Zone Change
/// </summary>
Zone = 0,
/// <summary>
/// Quad Change
/// </summary>
Quad = 1,
};

Next we need to add this enum to the BalanceBoardState struct itself. We do this as follows:

/// <summary>
/// The Action which has Triggered the Step Event
/// </summary>
[DataMember]
public StepType StepType;

With this done we now have all the foundations needed for the “Event”, now we need to add it! Open up Wiimote.cs and add the following block at the top just below the equivalent WiimoteChanged and WiimoteExtensionChanged handles.

/// <summary>
/// Event raised when a Balance Board Step is Triggered
/// </summary>
public event EventHandler<BalanceBoardStepEventArgs> BalanceBoardStep;

This defines our brand new BalanceBoardStep handle. With this in place we now need to be able to trigger it.  As we are going to use either a change in Zone or Quad location to trigger the call.

Update the Area struct (DataTypes.cs) to include two additional definitions as shown below:

/// <summary>
/// Last Balance Board Zone Area
/// </summary>
[DataMember]
public string LastZone;

/// <summary>
/// Last Balance Board Quad Area
/// </summary>
[DataMember]
public string LastQuad;

These 2 new definitions simply provide us with a location to archive the states of both Zone and Quad. I chose to add them like this as there is likely to be other occasions when access to this information would provide useful! Also facility is provided for standard WiimoteState access (just in case).

With this complete we now need to add the code to facilitate the trigger. Still within Wiimote.cs add the following two blocks just below the Area.Quad and Area.Zone updates within ParseExtension:

#region step filtering quad

// calculate if there is a Quad Step
if (mWiimoteState.BalanceBoardState.Area.CurrentQuad != mWiimoteState.BalanceBoardState.Area.LastQuad)
{
// update the archived Quad
mWiimoteState.BalanceBoardState.Area.LastQuad = mWiimoteState.BalanceBoardState.Area.CurrentQuad;
// post a Standard Step event
if (BalanceBoardStep != null)
{ BalanceBoardStep(this, new BalanceBoardStepEventArgs(mWiimoteState.BalanceBoardState, StepType.Quad)); }
}

#endregion step filtering quad

#region step filtering zone

// calculate if there is a Zone Step
if (mWiimoteState.BalanceBoardState.Area.CurrentZone != mWiimoteState.BalanceBoardState.Area.LastZone)
{
// update the archived Zone
mWiimoteState.BalanceBoardState.Area.LastZone = mWiimoteState.BalanceBoardState.Area.CurrentZone;
// post a Standard Step event
if (BalanceBoardStep != null)
{ BalanceBoardStep(this, new BalanceBoardStepEventArgs(mWiimoteState.BalanceBoardState, StepType.Zone)); }
}

#endregion step filtering zone

All we are doing here is comparing states. If there is a change we then call the Event and also update the archived state for the next comparison.

With this done our new BalanceBoardStep Event is now complete.. well nearly!

So how do we use it? The easy answer is in exactly the same way you would both the UpdateWiimoteChanged and UpdateExtensionChanged Events provided in the Wiimote Test Example that comes with WiimoteLib.

First within WiimoteInfo.cs create a new delegate referance below the 2 existing ones for Wiimote State/Extension:

private delegate void UpdateBalanceBoardStepDelegate(BalanceBoardStepEventArgs args);

Next we need to add a function to invoke the delegate, this allows for cross thread calls and is triggered a call from the main application

public void UpdateStep(BalanceBoardStepEventArgs args)
{
BeginInvoke(new UpdateBalanceBoardStepDelegate(UpdateBalanceBoardStep), args);
}

Finally we add our work function. This function receives the Event and then uses the arguments provided to detirmine the required action  to take in an equivalent manner of  the existing Wiimote State/Extension functions.

/// <summary>
/// Board Step example to show triggering of action via one of the two current step filters
/// Quad – Triggered via a change in Quad Area
/// Zone – Triggered via a change in Zone Area
/// </summary>
private void UpdateBalanceBoardStep(BalanceBoardStepEventArgs args)
{
BalanceBoardState bb = args.BalanceBoard;

switch (args.StepType)
{
case StepType.Quad:
// Quadrant output usefull for WiiFit Step game equivalents
lblQuad.Text = bb.Area.CurrentQuad;
Console.WriteLine(“Call from quad step”);
break;
case StepType.Zone:
// Quadzone output usefull for WiiFit Step game equivalents
lblZone.Text = bb.Area.CurrentZone;
Console.WriteLine(“Call from zone step”);
break;
}
}

We now have everything in place but before we can use the new Event we need to register it with the Wiimote etc as you would with the existing ones.

In your connection call add (MultipleWiimoteForm.cs/SingleWiimoteForm.cs) the following below the WiimoteChanged and WiimoteExtensionChanged register calls:

wm.BalanceBoardStep += wm_BalanceBoardStep;

Finally also add the corresponding function which is used to call the update within the WiimoteInfo.cs just below the equivalent State/Extension ones:

void wm_BalanceBoardStep(object sender, BalanceBoardStepEventArgs e)
{
WiimoteInfo wi = mWiimoteMap[((Wiimote)sender).ID];
wi.UpdateStep(e);
}

That’s it debug the program and enjoy…!

Update: Step ON and Step OFF

Ok we could stop here but lets expand things a little bit more by adding to the step Event facility a check too see weather we are “ON/OFF” the Board.

To do this we are going to add a check for a defined “Minimum Weight”. If the WeightKg is greater than the Minimum Weight then we are classed as being “On” the board. Simple eh! Start off by adding a the following new definitions to the BalanceBoardState struct:

/// <summary>
/// Are we on the Balance Board
/// </summary>
[DataMember]
public bool OnBoard;

/// <summary>
/// Balance Board Minimum Weight Tolerance
/// </summary>
[DataMember]
public double Tolerance;

Before we can use these new definitions we need to initialize them by assigning some default values. At the top of Wiimote.cs just above the Default constructor add the following :

// Temporary Defaults
private double Tolerance = 6;

This enables access to the default value for customization at start up. This value can then be updated at run time, why? I have currently access to 2 boards. At rest one reads 2kg and the other 5kg, go figure!

Add the following to the SetBalanceBoardDefaults() function to set the default values.

// set the default min weight used to trigger board use etc
mWiimoteState.BalanceBoardState.Tolerance = Tolerance;
mWiimoteState.BalanceBoardState.OnBoard = false;

Please note I always assume the user not to be on the Board at startup. With these definitions in place we can now use them to check for both the stepping On and Off events but before we do that we need to add them to the StepType enum within DataTypes.cs as follows:

/// <summary>
/// Step On
/// </summary>
On = 2,
/// <summary>
/// Step Off
/// </summary>
Off = 3,

Ok, now everything is in place lets use it. The next step is to enclose the existing Quad Zone and Step code in an IF statement that polls the weight against the tolerance. Here is our statement without the contents:

if (mWiimoteState.BalanceBoardState.WeightKg > mWiimoteState.BalanceBoardState.Tolerance)
{
// step ON event check  – (we will cover this next)
// calculate and set values for Quad
// calculate and set values for Zone
// step filtering Quad
// step filtering Zone
}
else
{
// step OFF event check – (we will cover this next)
}

Please update your Wiimote.cs to reflect the above. Once complete the next step is to add Triggers for both the OFF and On events. These event call are similar to those of Quad and Zone. Replace the //step On event check comment with the following block:

#region On Board Step Event Check

if (!mWiimoteState.BalanceBoardState.OnBoard)
{
mWiimoteState.BalanceBoardState.OnBoard = true;
if (BalanceBoardStep != null)
{ BalanceBoardStep(this, new BalanceBoardStepEventArgs(mWiimoteState.BalanceBoardState, StepType.On)); }
}

#endregion On Board Step Event Check

Next replace the // step OFF event check comment with:

#region Off Board Step Event Check

if (mWiimoteState.BalanceBoardState.OnBoard)
{
mWiimoteState.BalanceBoardState.OnBoard = false;
if (BalanceBoardStep != null)
{ BalanceBoardStep(this, new BalanceBoardStepEventArgs(mWiimoteState.BalanceBoardState, StepType.Off)); }
}

#endregion Off Board Step Event Check

Finally all we need to do is update the UpdateBalanceBoardStep function within WiimoteInfo.cs by adding the following cases to the switch statement:

case StepType.On:
// Your Code
break;
case StepType.Off:
// Your Code
break;

There you have it! additional facility for logging when a user gets ON/OFF the balance board.

Please note that this instruction assumes familiarity with the Quadrant and Quadzone instructions.

Similar to the Grouping GOG instruction we are going to start by modifying the DataTypes.cs file  by grouping the two existing definitions by grouping them together in a new struct.

Replace both the Quadrant and Quadzone definitions with the following singular block of code:

/// <summary>
/// Area of most Weight/COG
/// </summary>
[DataMember]
public Area Area;

Next we are going to add the new struct so that we can use this definition. Below the BalanceBoardState struct add the following code:

/// <summary>
/// Area Types and Variables
/// </summary>
[Serializable]
[DataContract]
public struct Area
{
/// <summary>
/// Current Balance Board Zone Area
/// </summary>
[DataMember]
public string CurrentZone;

/// <summary>
/// Current Balance Board Quad Area
/// </summary>
[DataMember]
public string CurrentQuad;

}

What we have here are 2 definitions for the current Quad and Zone. All we really need to do now is to update the existing Quadrant and Quadzone definitions to reflect the new Area.Quad and Area.Zone setup.

Open up Wiimote.cs and add the following (or replace) the following definitions to the balance board case within ParseExtension. Just below the COG ones:

// Shorthand the values for lazyness (Kg)
float TLkg = mWiimoteState.BalanceBoardState.SensorValuesKg.TopLeft;
float TRkg = mWiimoteState.BalanceBoardState.SensorValuesKg.TopRight;
float BLkg = mWiimoteState.BalanceBoardState.SensorValuesKg.BottomLeft;
float BRkg = mWiimoteState.BalanceBoardState.SensorValuesKg.BottomRight;

The above stays the same as in the Quadrant and Quadzone instructions. The following is the new Quad:

#region calculate and set values for quad

// Merged Version
if (TLkg > TRkg && TLkg > BRkg && TLkg > BLkg) { mWiimoteState.BalanceBoardState.Area.CurrentQuad = “Top Left”; }
if (TRkg > TLkg && TRkg > BRkg && TRkg > BLkg) { mWiimoteState.BalanceBoardState.Area.CurrentQuad = “Top Right”; }
if (BLkg > TLkg && BLkg > BRkg && BLkg > TRkg) { mWiimoteState.BalanceBoardState.Area.CurrentQuad = “Bottom Left”; }
if (BRkg > TLkg && BRkg > BLkg && BRkg > TRkg) { mWiimoteState.BalanceBoardState.Area.CurrentQuad = “Bottom Right”; }

#endregion calculate and set values for quad

And here we have the new Zone:

#region calculate and set values for zone

if ((TLkg + TRkg) > (TLkg + BLkg) &&
(TLkg + TRkg) > (TLkg + BLkg) &&
(TLkg + TRkg) > (BLkg + BRkg))
{
mWiimoteState.BalanceBoardState.Area.CurrentZone = “Top”;
}

if ((BLkg + BRkg) > (TLkg + BLkg) &&
(BLkg + BRkg) > (TLkg + BLkg) &&
(BLkg + BRkg) > (TLkg + TRkg))
{
mWiimoteState.BalanceBoardState.Area.CurrentZone = “Bottom”;
}

if ((TLkg + BLkg) > (TLkg + TRkg) &&
(TLkg + BLkg) > (BLkg + BRkg) &&
(TLkg + BLkg) > (TRkg + BRkg))
{
mWiimoteState.BalanceBoardState.Area.CurrentZone = “Left”;
}

if ((TRkg + BRkg) > (TLkg + TRkg) &&
(TRkg + BRkg) > (BLkg + BRkg) &&
(TRkg + BRkg) > (TLkg + BLkg))
{
mWiimoteState.BalanceBoardState.Area.CurrentZone = “Right”;
}

#endregion calculate and set values for zone

And that’s it! You can call the new code definitions (ie from within WiimoteInfo.cs) as follows:

// Quadrant output can also be run from here
lblQuad.Text = ws.BalanceBoardState.Area.CurrentQuad;

// Quadzone output can also be run from here
lblZone.Text = ws.BalanceBoardState.Area.CurrentZone;

So why bother doing this, you may ask…. Well….

I have posted a new version of WiimoteLib as a beta for people to play around with the Wii MotionPlus accessory.  Please note that this is not a stable release and should only be used if you wish to mess around with the MotionPlus.  Also note that only C# source code is included in this release as it is not a final build.  Here’s the change log:

v1.8.0.0

• Taiko Drum Master’s TaTaCon drum controller supported (Dean Herbert)
• Bare-bones Wii MotionPlus support (wiibrew.org, testing by Tyler Tolley)
• WiimoteTest UI changed to add MotionPlus data
  • Please note that the current version is VERY flakey and may not work at all for you.
  • Pair your Wiimote, plug in your MotionPlus, call InitializeMotionPlus()
  • Extensions plugged into the MotionPlus will give wacky results…not supported…yet!
  • Internal changes to perhaps fix some threading issues

So remember, it’s a beta, it may not work for you, and the data you’ll get back from the accessory is just the raw data it provides.  You won’t get real orientation values.

That said, head over to CodePlex and give it a try! (Brian Peek)

Great work Brian!

Using the format of the Wiimote Test application, once complete this instruction will enable access to each COG output as follows:

// Standard COG
lblCOG.Text = ws.BalanceBoardState.CenterOfGravity.Standard.ToString();
// Dampened COG
lblDampenedCOG.Text = ws.BalanceBoardState.CenterOfGravity.Dampened.ToString();

Before you start this instruction assumes use of a raw copy of WiimoteLib 1.7 and have looked at the Adding Dampened COG to WiimoteLib instruction.

Here is how its done:

First we are going to add new public struct CenterOfGravity to Data Types.cs. Just below the existing BalanceBoardState struct add the following block of code:

/// <summary>
/// Center Of Gravity Types and Variables
/// </summary>
[Serializable]
[DataContract]
public struct CenterOfGravity
{
/// <summary>
/// Center of gravity of Balance Board user
/// </summary>
[DataMember]
public PointF Standard;
/// <summary>
/// Dampened Center of gravity of Balance Board
/// </summary>
[DataMember]
public Point Dampened;
/// <summary>
/// Offset for Center of gravity Damping
/// </summary>
[DataMember]
public Point DampOffset;
/// <summary>
/// Limits for Center of gravity Damping
/// </summary>
[DataMember]
public int DampX, DampY;
}

As you can see this block contains all the same code as within the previous dampened COG instruction, however we have also added a new member “Standard”. Standard is going to reflect the existing COG setup when we are done.

Next (Assuming a raw copy of WiimoteLib 1.7) we need to remove the existing code block defining CenterOfGravity from the BalanceBoardState struct:

/// <summary>
/// Center of gravity of Balance Board user
/// </summary>
[DataMember]
public PointF CenterOfGravity;

and replace it with the following new definition:

/// <summary>
/// Center of gravity of Balance Board user
/// </summary>
[DataMember]
public CenterOfGravity CenterOfGravity;

Next we need to add the following two new functions to Wiimote.cs, I have included them just below the ParseExtension function. These functions are used to provide an initial damping offset (calibration value) and calculate the Dampened COG at run time. These functions are in essence the same as within the dampened COG instruction, however now containing the new updated syntax.

/// <summary>
/// Function used to set the damping offset
/// </summary>
public void SetDampenOffset()
{ mWiimoteState.BalanceBoardState.CenterOfGravity.DampOffset = GetDampenedCenterOfGravity(); }

/// <summary>
/// Function to get Dampened COG without the offset so it can also be used to set the offset
/// </summary>
private Point GetDampenedCenterOfGravity()
{
mWiimoteState.BalanceBoardState.CenterOfGravity.Dampened.X += -(mWiimoteState.BalanceBoardState.SensorValuesRaw.TopLeft + mWiimoteState.BalanceBoardState.SensorValuesRaw.BottomLeft);
mWiimoteState.BalanceBoardState.CenterOfGravity.Dampened.Y += -(mWiimoteState.BalanceBoardState.SensorValuesRaw.TopLeft + mWiimoteState.BalanceBoardState.SensorValuesRaw.TopRight);
mWiimoteState.BalanceBoardState.CenterOfGravity.Dampened.X += (mWiimoteState.BalanceBoardState.SensorValuesRaw.TopRight + mWiimoteState.BalanceBoardState.SensorValuesRaw.BottomRight);
mWiimoteState.BalanceBoardState.CenterOfGravity.Dampened.Y += (mWiimoteState.BalanceBoardState.SensorValuesRaw.BottomLeft + mWiimoteState.BalanceBoardState.SensorValuesRaw.BottomRight);

if (mWiimoteState.BalanceBoardState.CenterOfGravity.DampX == 0 || mWiimoteState.BalanceBoardState.CenterOfGravity.DampY == 0)
{
mWiimoteState.BalanceBoardState.CenterOfGravity.DampX = 500; // hack to cater for zero value at start up
mWiimoteState.BalanceBoardState.CenterOfGravity.DampY = 800; // hack to cater for zero value at start up
}

int DampX = mWiimoteState.BalanceBoardState.CenterOfGravity.DampX;
int DampY = mWiimoteState.BalanceBoardState.CenterOfGravity.DampY;

mWiimoteState.BalanceBoardState.CenterOfGravity.Dampened.X = mWiimoteState.BalanceBoardState.CenterOfGravity.Dampened.X / DampX;
mWiimoteState.BalanceBoardState.CenterOfGravity.Dampened.Y = mWiimoteState.BalanceBoardState.CenterOfGravity.Dampened.Y / DampY;

return mWiimoteState.BalanceBoardState.CenterOfGravity.Dampened;
}

As before, inclusion of the DampX and DampY variables enables individual axis stiffness customization, which is usefull due the rectangular nature of the Balance Board.

Next in order to use these functions we need to add the following code to the parse extension function. I do this just below the existing COG code:

Point DCOG = GetDampenedCenterOfGravity();

mWiimoteState.BalanceBoardState.CenterOfGravity.Dampened.X = DCOG.X – mWiimoteState.BalanceBoardState.CenterOfGravity.DampOffset.X;
mWiimoteState.BalanceBoardState.CenterOfGravity.Dampened.Y = DCOG.Y – mWiimoteState.BalanceBoardState.CenterOfGravity.DampOffset.Y;

Whilst we are here we also need to update the existing COG code to reflect the new syntax. Just above the code you have just put in update the COG alocations to reflect the following:

mWiimoteState.BalanceBoardState.CenterOfGravity.Standard.X = ((float)(Kx – 1) / (float)(Kx + 1)) * (float)(-BSL / 2);
mWiimoteState.BalanceBoardState.CenterOfGravity.Standard.Y = ((float)(Ky – 1) / (float)(Ky + 1)) * (float)(-BSW / 2);

Ok, we are nearly done. Finally we need to add a call to the SetDampenOffset() function in order to define an offset value at start up. Still within Wiimote.cs add the following call within InitializeExtension() inside the ExtensionType.BalanceBoard case,  just above the break.

SetDampenOffset();

And thats it, now you should have acces to both the Standard and Dampened COG values via the new CenterOfGravity grouping. As a final thought, yes it has dawned on me that dampened may be better as damped lol!

Update: The SetBalanceBoardDefaults() Function

Whilst developing the code for the Orientation implementation, it became apparent that there was need for an initialize function that could be used to define defaults and provide facility for resetting etc.

I have decided to add the definition here as really Damped COG  is the first time that we needed its capabilities, remember the hack to cater for zero values at start up:

if (mWiimoteState.BalanceBoardState.DampX == 0 || mWiimoteState.BalanceBoardState.DampY == 0)
{
mWiimoteState.BalanceBoardState.DampX = 500; // hack to cater for zero value at start up
mWiimoteState.BalanceBoardState.DampY = 800; // hack to cater for zero value at start up
}

This modification will not only allow us to remove it, but also provide a location for defining other variables later on. Start off by adding the following variable definitions to the top of Wiimote.cs just above the default constructor:

private int Dx = 500;
private int Dy = 800;

Next we need to add the function itself. Add the following right below the ParseExtension function:

/// <summary>
/// Function used to set the initial defaults.
/// These can be customised above and/or at runtime.
/// </summary>
private void SetBalanceBoardDefaults()
{
// set the individual damping tolerances for both the
// X and Y axies of the board (good for a rectangle)
mWiimoteState.BalanceBoardState.CenterOfGravity.DampX = Dx;
mWiimoteState.BalanceBoardState.CenterOfGravity.DampY = Dy;
}

With this in place all we need to do now is to add a call to the function at startup. Add the following (Currently I am undecided about merging the two together!) right before the call to SetDampenOffset() within the InitializeExtension() function.

SetBalanceBoardDefaults();

With that done we are finished and now have provision for defining defaults etc!

Here’s how its done:

First of all open up Data Types.cs and add the following code block within the BalanceBoardState struct:

/// <summary>
/// Current Balance Board Zone
/// </summary>
[DataMember]
public string Quadzone;

Next open up Wiimote.cs and locate the parse extension function. For convenience sake the following block shorthands the values included with WiimoteLib to help with RSI. Add the following code below the existing COG code just above the break:

// Shorthand the values for lazyness (Raw)
// float TLrkg = mWiimoteState.BalanceBoardState.SensorValuesRaw.TopLeft;
// float TRrkg = mWiimoteState.BalanceBoardState.SensorValuesRaw.TopRight;
// float BLrkg = mWiimoteState.BalanceBoardState.SensorValuesRaw.BottomLeft;
// float BRrkg = mWiimoteState.BalanceBoardState.SensorValuesRaw.BottomRight;

// Shorthand the values for lazyness (Kg)
float TLkg = mWiimoteState.BalanceBoardState.SensorValuesKg.TopLeft;
float TRkg = mWiimoteState.BalanceBoardState.SensorValuesKg.TopRight;
float BLkg = mWiimoteState.BalanceBoardState.SensorValuesKg.BottomLeft;
float BRkg = mWiimoteState.BalanceBoardState.SensorValuesKg.BottomRight;

As you can see I have included facility for using the raw values, but personally I have not found a need to yet! Next we need to add the code that will enable Zone output at run time. Below the shorthand code add the following block:

if ((TLkg + TRkg) > (TLkg + BLkg) &&
(TLkg + TRkg) > (TLkg + BLkg) &&
(TLkg + TRkg) > (BLkg + BRkg)) { mWiimoteState.BalanceBoardState.Quadzone = “Top”; }

if ((BLkg + BRkg) > (TLkg + BLkg) &&
(BLkg + BRkg) > (TLkg + BLkg) &&
(BLkg + BRkg) > (TLkg + TRkg)) { mWiimoteState.BalanceBoardState.Quadzone = “Bottom”; }

if ((TLkg + BLkg) > (TLkg + TRkg) &&
(TLkg + BLkg) > (BLkg + BRkg) &&
(TLkg + BLkg) > (TRkg + BRkg)) { mWiimoteState.BalanceBoardState.Quadzone = “Left”; }

if ((TRkg + BRkg) > (TLkg + TRkg) &&
(TRkg + BRkg) > (BLkg + BRkg) &&
(TRkg + BRkg) > (TLkg + BLkg)) { mWiimoteState.BalanceBoardState.Quadzone = “Right”; }

If you want you can also add definitions for angle zones however as with the raw value definitions I dont really find much use for them, however here they are just in case:

//if ((TLkg + BRkg) > (TLkg + TRkg) &&
//     (TLkg + BRkg) > (BLkg + BRkg) &&
//     (TLkg + BRkg) > (TLkg + BLkg) &&
//     (TLkg + BRkg) > (TRkg + BLkg)) { mWiimoteState.BalanceBoardState.Quadzone = “Left-Right”; }

//if ((TRkg + BLkg) > (TLkg + TRkg) &&
//     (TRkg + BLkg) > (BLkg + BRkg) &&
//     (TRkg + BLkg) > (TLkg + BLkg) &&
//     (TRkg + BLkg) > (TLkg + BRkg)) { mWiimoteState.BalanceBoardState.Quadzone = “Right-Left”; }

Once complete Quadzone is now available by the normal means for example:

WiimoteState ws = state;
BalanceBoardState bb = ws.BalanceBoardState;

string current_zone = bb.Quadzone;

That’s all there is to it easy eh!

When used in conjunction with the Quadzone Filter you have the basic tools needed for very simple forms of navigation. As with the Quadzone filter, output is fed back as a string which can then be used as desired eg in a switch or if statement etc.

So without further ado heres how its done:

First of all open up Data Types.cs and add the following code block within the BalanceBoardState struct:

/// <summary>
/// Current Balance Board Quadrant, SJB
/// </summary>
[DataMember]
public string Quadrant;

Next open up Wiimote.cs and locate the parse extension function. For convenience sake the following block shorthands the values included with WiimoteLib. The code is the same as that used in the Quadzone tutorial so if you have already implemented it there you can skip this step, otherwise add the following code below the existing COG code just above the break:

// Shorthand the values for lazyness (Raw)
// float TLrkg = mWiimoteState.BalanceBoardState.SensorValuesRaw.TopLeft;
// float TRrkg = mWiimoteState.BalanceBoardState.SensorValuesRaw.TopRight;
// float BLrkg = mWiimoteState.BalanceBoardState.SensorValuesRaw.BottomLeft;
// float BRrkg = mWiimoteState.BalanceBoardState.SensorValuesRaw.BottomRight;

// Shorthand the values for lazyness (Kg)
float TLkg = mWiimoteState.BalanceBoardState.SensorValuesKg.TopLeft;
float TRkg = mWiimoteState.BalanceBoardState.SensorValuesKg.TopRight;
float BLkg = mWiimoteState.BalanceBoardState.SensorValuesKg.BottomLeft;
float BRkg = mWiimoteState.BalanceBoardState.SensorValuesKg.BottomRight;

As you can see I have included suggested functionality for using the raw values, but personally I have not found a need to yet. Its just there for reference! Next we need to add the code that will enable Quadrant output at run time. Below the shorthand code add the following block:

// Calculate the heavest quadrant
if (TLkg > TRkg && TLkg > BRkg && TLkg > BLkg) { mWiimoteState.BalanceBoardState.Quadrant = “TL”; }
if (TRkg > TLkg && TRkg > BRkg && TRkg > BLkg) { mWiimoteState.BalanceBoardState.Quadrant = “TR”; }
if (BLkg > TLkg && BLkg > BRkg && BLkg > TRkg) { mWiimoteState.BalanceBoardState.Quadrant = “BL”; }
if (BRkg > TLkg && BRkg > BLkg && BRkg > TRkg) { mWiimoteState.BalanceBoardState.Quadrant = “BR”; }

Once complete Quadrantis available by the normal means for example:

WiimoteState ws = state;
BalanceBoardState bb = ws.BalanceBoardState;

string current_quad = bb.Quadrant;

//Or following the Wiimote Test example
lblQuad.Text = ws.BalanceBoardState.Quadrant;

That’s all there is to it easy eh! If you haven’t seen the Quadzone tutorial yet, go check it out. The two methods compliment each other greatly!