Initial Thoughts: Raspberry Pi 2 and Windows IoT Core

Over the past week I’ve been taking a look at Windows IoT Core running on a Raspberry Pi 2. Windows IoT Core is a powerful new operating system from Microsoft that currently runs on the ARM-based Raspberry Pi 2 and the Intel-powered, x86-based MinnowBoard Max.

Until now, the Raspberry Pi has mostly run a collection of Linux-based operating systems. Microsoft, as part of their recent push into the IoT market, is looking to change this by releasing a version of Windows that runs on these more resource-constrained devices. The result is Windows IoT Core, a surprisingly strong first step into a segment previously dominated by Linux.

In this post I’ll be taking a look at the Raspberry Pi 2’s hardware, followed by an overview of Windows IoT Core. At the end I’ll show a sample project that integrates with and enables the use of Netduino Go modules with this new platform.

Continue reading Initial Thoughts: Raspberry Pi 2 and Windows IoT Core

SplatNet 2 Login Changes (and How to Avoid Making Nintendo Angry)

Background: I made Splatoon2.ink, a site that shows the current and upcoming map schedules for Nintendo’s Splatoon 2. It pulls data from SplatNet2, their app/site that connects you to game info via the Nintendo Switch mobile app. More information about the SplatNet 2 API can be found here, and source code for Splatoon2.ink can be found here.

Yesterday, a number of sites and tools that pull data from SplatNet 2 stopped working. This seems to be caused by a change to the Nintendo Switch app’s login procedure:

This new parameter appears to be an HMAC SHA256 hash that is likely made up of several pieces of user data and, potentially, a secret key stored within the app itself. Depending on how they’ve implemented this, it may be difficult or impossible to determine how to calculate this hash.

Continue reading SplatNet 2 Login Changes (and How to Avoid Making Nintendo Angry)

MicroTweet 2

Back in 2011 I released a Twitter OAuth API client library for the .NET Micro Framework called MicroTweet. Here’s the original blog post about it.

A lot has changed since then: most notably, Twitter deprecated and disabled their v1.0 API and started enforcing the use of SSL connections to access API endpoints. These changes meant that the original MicroTweet library hasn’t worked for quite some time (sorry!).

After receiving my Netduino 3 Wi-Fi (which features built-in SSL support) I thought it might be interesting to revisit this library and update it to work with Twitter’s new API requirements.

The result is MicroTweet 2 — now available on GitHub and as a binary package on NuGet.

In this post I’ll go over some of the changes to the library and its development process.

Continue reading MicroTweet 2

Seven Segment Display Driver Updated

Netduino 3 Wi-Fi
I’ve just posted an update to the Seven Segment Display driver, bringing it to version 1.1.0. This update brings support for the .NET Micro Framework v4.3 and the newly-released Netduino 3 Wi-Fi. It also contains a few bug fixes and adds XML comments for each of the driver’s public members.
You can download the latest version of the driver and its source code here: Komodex Labs – Downloads.
I’ve also posted some initial thoughts on the new Netduino 3 Wi-Fi on my personal blog here. Additionally, I wrote a separate post about an alternate GoBus library I developed here.
As always, please let me know if you have any questions or issues. Enjoy!

GoBus: An Alternate Approach

When I first received the new Netduino 3 Wi-Fi I was very eager to test its GoBus functionality. There was one problem, though: the firmware it was running didn’t include the library needed for GoBus to work.

This gave me a chance to reimagine how GoBus could be implemented. I started thinking about a new, more flexible architecture that enabled complete customization while still remaining simple and easy-to-use.

I ended up implementing these ideas in an experimental GoBus library that, for the moment, I’m calling GoBusExperimental. (Catchy, I know.)

In this post I’ll start by going over my goals and some of the implementation details. If you’re just here for the cool pictures and experiments (I can’t blame you!) scroll down to the Customization section to see some of the things this library enables.

It’s important to note that everything in this library should be considered experimental. I haven’t spent much time implementing and organizing/thinking about this approach and it definitely shouldn’t be considered “final” in any way. I’m definitely open to hear suggestions for changes and improvements as well.

Continue reading GoBus: An Alternate Approach

Netduino 3 Wi-Fi Review

Two new Netduinos were announced today: the Netduino 3 Wi-Fi and the Netduino 3 Ethernet! The Wi-Fi version ships today, and the Ethernet version is scheduled to ship in late June now shipping! You can view Chris Walker’s announcement post on the Netduino forums here.

Update, August 8, 2015: The Netduino 3 Ethernet is now shipping (forum thread here). Also available is the Netduino 3 (base model, no networking). The forum thread for the base Netduino 3 is here.

I’ve been testing the Netduino 3 Wi-Fi for the past few weeks and I can easily say it’s the best Netduino hardware ever released. This board is awesome.

There are two huge differences with this model compared to the previous Netduino Plus 2: the Ethernet port has been replaced with Wi-Fi (2.4GHz 802.11b/g/n via TI’s CC3100) and three GoBus ports have been added along the right edge of the board. Even with these additions the board is still very small — only about half an inch wider than the NP2.

With the Netduino 3 Wi-Fi you get everything you’ve come to expect from a Netduino: most notably, beautifully crafted hardware with features to match.

Continue reading Netduino 3 Wi-Fi Review

Managing XAML Resources in Universal Windows Phone 8.1 and Windows 8.1 Apps

Universal apps for Windows 8.1 and Windows Phone 8.1 allow you to share both code and XAML resources between desktop and phone versions of an application. Anything contained in the “Shared” pseudo-project gets compiled individually into each platform-specific project:

universalsolution

This is unlike Portable Class Libraries where a single assembly is compiled and shared between the projects that use it. Files in the “Shared” project are included and compiled directly alongside the platform-specific projects’ own files.

This enables some nice features. For instance, you can write conditional code blocks (using #if) to change application behavior between different platforms. New Universal apps have the WINDOWS_PHONE_APP and WINDOWS_APP symbols defined for this purpose:

#if WINDOWS_PHONE_APP
    Debug.WriteLine("Hello from Windows Phone!");
#elif WINDOWS_APP
    Debug.WriteLine("Hello from Windows!");
#endif

Sharing XAML Resources

XAML resources are a bit different. It isn’t currently possible to have conditional XAML within a single file (although there is at least one effort being made toward that goal), so you either have to share the entire file or make a separate copy for each platform.

If you want to define app-wide XAML resources (outside of the context of a particular page or control) you might typically do that in App.xaml. But if you share App.xaml/App.xaml.cs between both the phone and desktop platforms (and you should!) then it becomes impossible to have different app-wide XAML resources on each platform.

Merged ResourceDictionaries

You can work around this issue by merging in platform-specific ResourceDictionaries within App.xaml:

<Application
    x:Class="TestUniversalXAML.App"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:TestUniversalXAML">
    
    <Application.Resources>
        <ResourceDictionary>
            <ResourceDictionary.MergedDictionaries>
                <ResourceDictionary Source="Themes/AppResources.xaml" />
            </ResourceDictionary.MergedDictionaries>
        </ResourceDictionary>
    </Application.Resources>

</Application>

In this example, the app will look for a file called Themes/AppResources.xaml and merge it into its main ResourceDictionary. This file could be either a shared or platform-specific file, and you can specify additional ResourceDictionaries to merge in as well. (This can get a bit tricky, however, if you need to reference static resources across different merged files, so it’s usually best to try to keep things contained in a single file if possible.)

For our needs, we’ll simply add a new Resource Dictionary with the specified name in each project. (Also, it’s worth noting that Resource Dictionary is now included in the list of file templates within Visual Studio, making this even easier.)

Here’s what the VS solution looks like with the platform-specific XAML resource dictionaries underlined in red:

universal-xamlresourcesFrom there, just put any XAML resources you need in the platform-specific AppResources.xaml file and they will become available throughout your application. Any styles or other resources will work in the Visual Studio designer window and the new XAML static resource autocompletion will continue to work exactly as you’d expect.

Easier Page and User Control Sharing

This also makes it easier to share pages and user controls between platforms.  You can reference platform-specific styles, DataTemplates, or any other static resource from shared pages/controls as long as a resource exists with the same name on each platform.

In most situations, this will probably be a better solution than modifying control properties from conditional code in the code behind. Not only does it help maintain the separation of code and layout, but it also works perfectly within the Visual Studio designer.

Here’s an example with a shared page. The style MyTextBlockStyle sets the text color to red on Windows Phone and green on Windows. (By the way, you can switch between viewing within the context of Windows or Windows Phone by using the drop-down box I’ve underlined in red.)

Windows Phone:

sharedpage-wp

Windows:

sharedpage-win

Finding Default Styles for Windows Phone 8.1 and Windows 8.1 XAML Controls

When you want to retemplate a XAML control, you can usually create a copy of its default template by right clicking the control within the Visual Studio Designer or Document Outline windows and selecting “Edit Template” or “Edit Additional Templates”:

xaml-edittemplatecopy

Clicking “Edit a Copy…” will allow you to name the new style and select where you want to put it. Visual Studio will copy over the default properties and point your control to use the new style.

In some situations, it may be difficult or impossible to select the control you wish to edit through the designer. Or, such as with this ContentDialog control, the option may be disabled:

xaml-edittemplatedisabled

For those situations, you can find the default styles for all Windows Phone 8.1 XAML controls in the following file:

C:\Program Files (x86)\Windows Phone Kits\8.1\Include\abi\Xaml\Design\generic.xaml

The equivalent file for Windows 8.1 XAML controls is located at:

C:\Program Files (x86)\Windows Kits\8.1\Include\winrt\xaml\design\generic.xaml

From there, you can copy the styles and templates you need into your app and modify them as necessary.

Eat What You Like, but Less Of It

If I were to write a diet book, that would be the title.

One year ago today I started tracking my weight. I had been overweight for a long time, but I had never made any serious effort to do anything about it. I actually didn’t even know how much I weighed.

Now, one year later, I’ve lost 70 pounds, I’m well within the “normal” BMI range for my height, and I feel better (both physically and psychologically) than I have in years.

A lot of people ask me how I did it or what my secret was. The truth is, there is no trick, and you probably already know the answer: diet and occasional exercise. That’s it.

I never knew how easy this could be. My whole life I believed it would take more effort than it actually did. I think a lot of people have these same misconceptions.

But there are a few things I learned along the way that helped me stay motivated. These changes have made a huge improvement in my quality of life and I hope by sharing my experiences I can inspire others to do the same.

Note: These are just my personal experiences of what worked for me. Different things work for different people, and what worked for me may not work for you. This is not medical advice. Consider talking to your doctor before starting a new diet plan.

Continue reading Eat What You Like, but Less Of It