Controlling your Treadmill from Silverlight

Controlling your Treadmill from Silverlight - Part 3

Controlling your Treadmill from Silverlight - Part 1
Controlling your Treadmill from Silverlight - Part 2

In the final post for this series, we will be expanding the usefulness of our application by adding a workout feature. This feature will allow you to craft workouts (in XML format of course) and then have the application execute them. The application will render a nice visualization so you can monitor your progress as you burn off those calories.

Separation of Concerns
As with any application, complexity can be your worst enemy. To keep your sanity, you need to manage your complexity so that you can easily maintain and expand your application in the future. At this point in time, the easiest step would be to start plugging logic into our Silverlight Page Code-behind. But this generally a bad idea for all but the most trivial of applications. Instead, we will opt to create a TreadmillContrller class and a WorkoutController class. The TreadmillController class will be responsible for playing the correct sounds to change the treadmill settings and the WorkoutController will be responsible for parsing the workout xml files and to instruct us when to change settings along our workout routine. This class also, builds the workout graph that will be displayed on the main screen. In retrospect, I should probably not be building the graph here, but it worked sufficiently well for this exercise.

TreadmillController Class

public class TreadmillController
{
public const double MAX_INCLINE = 10;
public const double MAX_SPEED = 10;
public const double DELTA = 0.5;
  
private readonly MediaElement m_soundPlayer;
private double m_currentSpeed;
private double m_currentIncline;
  
public TreadmillController()
{
    m_soundPlayer = new MediaElement {Volume = 0.5};
}
  
public bool ChangeTreadmillSettings(double speed, double incline)
{
    if(speed < 0 || incline < 0)
        return false;
    if(speed > MAX_SPEED || incline > MAX_INCLINE)
        return false;
  
    string fileName = string.Format("{0}_{1}.mp3", speed * 10, incline * 10);
    Uri resourceUri = new Uri("SilverTread;component/sounds/" + fileName, UriKind.Relative);
    StreamResourceInfo sri = Application.GetResourceStream(resourceUri);
    if (sri != null)
    {
        m_soundPlayer.SetSource(sri.Stream);
    }
    else
    {
        System.Diagnostics.Debug.WriteLine("File Not Found: " + fileName);
    }
  
    m_currentSpeed = speed;
    m_currentIncline = incline;
  
    return true;
}
  
public double CurrentSpeed
{
    get { return m_currentSpeed; }
}
  
public double CurrentIncline 
{
    get { return m_currentIncline; }
}

WorkoutController Class

public class WorkoutController
{
    private List<Checkpoint> m_checkpoints;
    private Dictionary<int, UIElement> m_graphSegments;
    private readonly DispatcherTimer m_timer;
    private readonly IWorkoutInfoView m_workoutInfoView;
  
    private bool m_workoutLoaded;
    private DateTime m_workoutStartTime;
    private Rectangle progress;
  
    private int m_previousCheckpointIndex = -1;
    private bool m_workoutStarted;
    
    public WorkoutController(IWorkoutInfoView workoutInfoView)
    {
        m_workoutInfoView = workoutInfoView;
  
        m_timer = new DispatcherTimer();
        m_timer.Interval = new TimeSpan(0, 0, 0, 0, 500);
        m_timer.Tick += new EventHandler(m_timer_Tick);
    }
  
    public void LoadProgram(string uri)
    {
        XDocument doc = new XDocument();
        doc = XDocument.Load(uri);
        int i = 0;
        var checkpoints = from checkpoint in doc.Descendants("workout").Descendants("checkpoint")
                          select new Checkpoint()
                          {
                              Time = int.Parse(checkpoint.Attribute("time").Value),
                              Speed = double.Parse(checkpoint.Attribute("speed").Value),
                              Incline = double.Parse(checkpoint.Attribute("incline").Value),
                              Index = i++
                          };
  
        m_checkpoints = checkpoints.ToList();
        m_workoutLoaded = true;
  
        BuildWorkoutGraph();
    }
  
  
    private void BuildWorkoutGraph()
    {
        m_graphSegments = new Dictionary<int, UIElement>();
        int totalTime = (int)GetProgramDuration().TotalSeconds;
        Grid graphGrid = new Grid();
  
        // Progress
        progress = new Rectangle();
        progress.Width = 0;
        progress.Height = m_workoutInfoView.WorkoutGraphContainer.ActualHeight;
        progress.Margin = new Thickness(5);
        progress.Style = App.Current.Resources["ProgressGraphRectangle"] as Style;
        progress.HorizontalAlignment = HorizontalAlignment.Left;
  
        // Speeds
        StackPanel speedGraph = new StackPanel();
        speedGraph.VerticalAlignment = VerticalAlignment.Bottom;
        speedGraph.Orientation = Orientation.Horizontal;
        speedGraph.Margin = new Thickness(5);
        int i = 0;
        foreach (var checkpoint in m_checkpoints)
        {
            Rectangle r = new Rectangle();
            r.VerticalAlignment = VerticalAlignment.Bottom;
            r.Height = (checkpoint.Speed / 10) * m_workoutInfoView.WorkoutGraphContainer.ActualHeight;
            r.Width = ((double)checkpoint.Time / totalTime) * m_workoutInfoView.WorkoutGraphContainer.ActualWidth;
            r.Style = App.Current.Resources["SpeedGraphRectangle"] as Style;
            r.SetValue(Rectangle.NameProperty, "GraphRect_" + i++);
            speedGraph.Children.Add(r);
            m_graphSegments.Add(checkpoint.Index, r);
        }
  
        // Inclines
        StackPanel inclineGraph = new StackPanel();
        inclineGraph.VerticalAlignment = VerticalAlignment.Bottom;
        inclineGraph.Orientation = Orientation.Horizontal;
        inclineGraph.Margin = new Thickness(5);
        foreach (var checkpoint in m_checkpoints)
        {
            Rectangle r = new Rectangle();
            r.VerticalAlignment = VerticalAlignment.Bottom;
            r.Height = (checkpoint.Incline / 10) * m_workoutInfoView.WorkoutGraphContainer.ActualHeight;
            r.Width = ((double)checkpoint.Time / totalTime) * m_workoutInfoView.WorkoutGraphContainer.ActualWidth;
            r.Style = App.Current.Resources["InclineGraphRectangle"] as Style;
            inclineGraph.Children.Add(r);
        }
  
        Rectangle background = new Rectangle();
        background.Fill = new SolidColorBrush(Colors.Black);
        background.Opacity = 0.3;
        background.Stretch = Stretch.UniformToFill;
  
        graphGrid.Children.Add(background);
        graphGrid.Children.Add(progress);
        graphGrid.Children.Add(speedGraph);
        graphGrid.Children.Add(inclineGraph);
        
  
        if (m_workoutInfoView.WorkoutGraphContainer.Children.Count > 0)
            m_workoutInfoView.WorkoutGraphContainer.Children.RemoveAt(0);
        m_workoutInfoView.WorkoutGraphContainer.Children.Add(graphGrid);
    }
  
    void m_timer_Tick(object sender, EventArgs e)
    {
        TimeSpan ts = DateTime.Now - m_workoutStartTime;
        TimeSpan remaining = GetProgramDuration() - ts;
  
        if (remaining.Seconds < 0)
        {
            StopProgram();
            return;
        }
  
        m_workoutInfoView.WorkoutDuration = ts;
        m_workoutInfoView.WorkoutTimeRemaining = remaining;
  
        progress.Width = (ts.TotalSeconds/GetProgramDuration().TotalSeconds)* m_workoutInfoView.WorkoutGraphContainer.ActualWidth;
  
        int currentCheckpoint = GetCurrentCheckpointIndex();
        if (m_previousCheckpointIndex != currentCheckpoint)
        {
            // Change treadmill settings.
            m_workoutInfoView.UpdateTreadmillSettings(m_checkpoints[currentCheckpoint].Speed, m_checkpoints[currentCheckpoint].Incline);
  
            if (m_previousCheckpointIndex != -1)
            {
                Rectangle previousRect = m_graphSegments[m_previousCheckpointIndex] as Rectangle;
                previousRect.Stroke = null;
            }
  
            Rectangle currentRect = m_graphSegments[currentCheckpoint] as Rectangle;
            currentRect.Stroke = new SolidColorBrush(Colors.Yellow);
  
            m_previousCheckpointIndex = currentCheckpoint;
        }
    }
  
    private TimeSpan GetProgramDuration()
    {
        if (!m_workoutLoaded)
        {
            throw new InvalidOperationException("No workout loaded");
        }
  
        int totalTime = 0;
        foreach (var checkpoint in m_checkpoints)
        {
            totalTime += checkpoint.Time;
        }
        return new TimeSpan(0, 0, 0, totalTime);
    }
  
    public int GetCurrentCheckpointIndex()
    {
        int elapsedTime = (int)(DateTime.Now - m_workoutStartTime).TotalSeconds;
        int accTime = 0;
        int i = 0;
        while (elapsedTime >= accTime && i < m_checkpoints.Count)
        {
            accTime += m_checkpoints[i++].Time;
        }
  
        return i - 1;
    }
  
    public void StopProgram()
    {
        if (m_workoutStarted)
        {
            m_workoutStarted = false;
            m_timer.Stop();
            m_workoutInfoView.UpdateTreadmillSettings(0, 0);
        }
    }
  
    public void StartProgram()
    {
        if (m_workoutLoaded)
        {
            m_workoutStarted = true;
            m_timer.Start();
            m_workoutStartTime = DateTime.Now;
        }
    }
  
    public bool WorkoutStarted
    {
        get { return m_workoutStarted; }
    }
  
}

I won't spend any time explaining the TreadmillController class since it is so trivial, but the WorkoutController class warrants some discussion. You may notice that the constructor of the WorkoutController class takes an IWorkoutInfoView. We are taking advantage of the Model-View-Controller pattern (MVC) to keep UI logic out of the business layer here. Our Silverlight codebehind (Page.xaml.cs) will implement this interface and we will inject this into the WorkoutController. Doing this really makes our codebehind lightweight as almost all of the logic is built into the controllers. Furthermore, our code is more testable this way since we don't have all of that UI logic to deal with.

The WorkoutController class is not very difficult to understand, it loads a workout xml file and uses a little LINQ to XML to parse the workout into a series of checkpoints. These checkpoints are stored in a list and are referenced while the graph is being generated and while the workout is executing.

Building the Graph
To build the graph, I simply iterate over the checkpoints and construct rectangle primitives of the appropriate sizes for speed and incline. The resulting graph is then assigned to the WorkoutGraphContainer declared in IWOrkoutInfoView, and in a polymorphic way, the UI is updated with the graph. It's like magic! I also added a progress bar that moves as the workout is executing. I feel like this gives you a better representation of your workout progress. This feature did not exist in the video, but you can see it in the screenshot below:

Conclusion
As I mentioned before, this application was just an experiment. It's of limited use, but it does demonstrate how you can come up with some cool things even when they seem impossible at first glance. There are a lot of directions that I could take this application. This is the last post for this series, but I may decide to revisit this sometime in the future. Below, I've made a list of some features that I would like to add when that time comes:

Add more information to the Stats panel. Include distance traveled, checkpoint time remaining, etc..
Allow the user to select a program to load.
Provide an interface for creating workouts, allow user to save workouts online.
Allow the user to change the speed and incline by dragging the mouse over the graphs (Requested by Andrew Duthie)
Add an emergency stop button.
Allow the user to skip parts of the exercise by clicking on the graph segment of their choice.
Display an actual progress percentage in the graph.
Make the incline graph a little more noticeable.
Calculate approximate calories burned (I think you need to know weight and height to do this).

Source Code
To download the source code for this post, click on the link below. I have not included the sounds, because they add a good bit of overhead to the download size and you can generate them yourself. Also, the code will still run without the sounds. Enjoy!

Download Source Code

posted @ Sunday, August 03, 2008 8:16 PM

Comments have been closed on this topic.

Archives

Post Categories

My Links

Controlling your Treadmill from Silverlight - Part 3