I spend most of my time on the Devices page, which lists all of the devices in all home automation networks on my account.  (Right now I only have a single Z-Wave network, but in theory I could have a potpourri of different networks that include other existing home automation frameworks, IR transceivers, and—I dunno—USB missile launchers?)

Anyway, the UI all works, and dynamically updates when a devices state changes.  Cool!

After merging all of Roomie’s desktop and web components into one self-aware Visual Studio solution, learning a ton of new technology, and a little trial and error, I now have the Roomie desktop client talking directly to the new website.  Best of all, I can locally debug everything which means that I can get quicker feedback on code changes and (shrug?) even develop offline.  Below I have a simple example pictured.  A more impressive example is when I tell the Roomie desktop client to say something using text-to-speech, but obviously that would not convey over a screenshot.

The Roomie desktop client communicates with the Roomie web service using a custom protocol that I developed.  Both the server side (web service) and client side (Roomie desktop client) reference the same Visual Studio project to do the communication, so I am guaranteed protocol agreement.  It’s really satisfying to add some functionality or refactor in one place and have the changes propagate to every related component.

Yaaaaay programming!

But enough technical talk.  Lets get to serious business.  Here I have a little RoomieScript that I wrote, just as a proof of concept.

<RoomieScript>
  <ZWave.PowerOff DeviceName="Coffee Pot" />
  <Core.Loop>
    <ZWave.WaitForChange DeviceName="Coffee Pot" PollInterval="5 Seconds" />
    <ZWave.PowerOff DeviceName="Coffee Pot" />
    <RoomieBot.TextDavid Text="No coffee!" />
  </Core.Loop>
</RoomieScript>

Here Roomie waits until the coffee maker is turned on, then turns it off and sends me a terse text message. Yes, it works!  And yes, I do use Roomie for legitimate things, but ah… it’s so just that much fun to be dumb.

Interested in beta testing Roomie?  Send me a message.

As you can see above, I have the Roomie website’s main page displaying on an iPad.  The first two controls are an example of the new feature.  Before I go to bed I might want to click the “set alarm” button, which would run a RoomieScript that I wrote that wakes me up in the morning.  The same deal goes for coffee. (Of course, making coffee is also part of the alarm routine.)  It would be easy to imagine many other virtual devices.  Eventually I will likely make a “basement” device, which would have buttons like “Movie” for nice movie lighting, “all on”, “all off”, and of course, “PAAARRTAAYY!”

I mentioned that these controls were highly customizable in code.  In the C# code-behind I can set the size of these controls with pixel precision.  That came in really handy when I made an iPad-specific page, which resizes the controls to be just the right width to fill the screen horizontally and high enough for easy pressing with a finger.  A tweak of the sizes only takes a few seconds.

All of this has been a really good learning experience for me, and of course I am far from done.  I’ve applied so much of what I’ve learned writing Roomie, which is just for fun, to other projects at work and in school.  If you want to help test Roomie, send me an email.

Arcadia Preview 2 (version 1.0.489.0) is finally here!

I’m really pleased with Arcadia’s progress.  Arcadia’s features currently include selecting repositories (where game files are kept), scanning for games (based on a user-editable vocabulary of platforms), and (most importantly) searching for and running ROMs in your favorite emulators of choice.

Thanks to FlotsamX for his usability feedback for Preview 1.

Download Arcadia Preview 2 here.

I’m not sure why I instinctively personify computers as needy and with low self esteem, but anyway…

In rewriting Roomie, I built up the infrastructure in the core engine to allow me to easily add commands.  In the old Roomie, I tried to organize commands’ code as best I could, but I still ended up with big files with lots of functions, and a hulking switch statement at the top.

Here is the switch statement for the Z-Wave commands code file:

There was also another junction point higher up the line that would decide which kind of command was being called.  In RoomieRemake, I do things a bit more generically.  Every command is represented by a class, which all derive from a “Command” class.  That means I can just have this:

As I continue development I will optimize things like command selection, but the point here is that I don’t have a whole bunch of special cases for different kinds of commands.  This is just part of the code that makes a command run, of course, but part of the redesign included breaking up functionality into neat, orderly bundles.  The master list of commands is populated dynamically with reflection.

A big time-waster in the old Roomie was validating variables, so in my new approach that is all handled in the definition of a higher-level “Command” class, while subclasses of Command register what arguments they expect, their types, and even default values if applicable.

Here is the old code for the ZWave.PowerOn and ZWave.PowerOff commands.  Look at all of the duplicate code.  Several times after redesigns I would have to go and manually change many lines of very similar code.

Comparing that to the new approach, here is the ZWave.PowerOn command:

By the time the command class is actually defined, Command has been abstracted into ZWave command, which has been further abstracted to SingleZWaveDeviceControlCommand.  Verbose, sure, but by the time I get to defining the command, I know that all of the validating of variables and finding of the device and connecting to the ZWave controller have already been taken care of.  Plus, if I ever want to add functionality to a group of similar commands, I can just write in the code in a parent class’s definition.  That’s inheritance and type safety at work.

You might have noticed that I didn’t include the whole method signature in the above screenshot.  That’s because it’s reaaallly long.  Some might see this as a disadvantage, but a big problem I had with the old Roomie is not having enough information to work with to make the proper decisions.  Basic commands recieve as arguments the CommandInterpreter that is calling them, a Scope object that represents the nested scopes containing variables, and an XmlNode containing the original command XML.  (Did you remember that RoomieScript is an XML based scripting language?)

That Z-Wave command was already really abstracted, with arguments defined in higher abstract classes, so here’s an example of a command that derives directly from Command:

Here the constructor calls a method defined in the Command class that defines an argument of type String.  By the time Execute_Definition is called, the engine has already verified that the Text argument is specified.  If there’s a problem, the engine reacts appropriately.  The CommandInterpreter, which represents a thread, doesn’t care about all of these extensions to Comamnd, of course.  It simply calls the selected command’s “Execute” method, which is concrete in the base Command class.

Finally, here’s a shot of the two Solution Explorer windows.  On the left is the old Roomie, and on the right is RoomieRemake.  You can see that in the remake, extra functionality is in other projects, which RoomieRemake hooks into as plugins at runtime.  That way, anyone could write a pluggin for Roomie.

SO that’s what I’m working on.  I hope to release this sometime in the near future.  If you’re interested in testing, either Roomie or Arcadia, shoot me an email.  If you think I’m a huge nerd, well you’re wrong.  I’m more accurately a gigantic geek, but you could call me a dork anyway.

(link)

With Arcadia I have committed to research everything that I suspect will make for a better design. Because of this, Archaida’s backend is shaping up to be elegant and efficient. I researched how to do inheritance in C#, and have used that to save myself from writing a lot of code. This has drastically decreased development and testing time. I learned how to use basic regular expressions over the summer, and have used them in some areas (more on that later). For the frontend I decided to switch from WinForms to WPF. All I can say is that databinding is epic, and I still have a lot more to learn about it.

Here’s a shot of Arcadia in its current form:

I’ll hopefully release an alpha soon.

edit October 12, 2009 at 10:57am:

Also generics. Generics are amazing. (More on that later, too.)

<roomieScript>

  <!–  this sends a script to the Desktop Computer  –>

  <!–  it’s really just to confirm that both computers are turned on  –>

  <webScripts.sendScript targetComputerName="Desktop Computer">

    <speak>

       

         all set!

    </speak>

  </webScripts.sendScript>

  <!– wait until the morning  –>

  <waitUntil hour="6" minute="0" second="0" />

  <!–  send a script to Home Server to handle the lights –>

  <webScripts.sendScript targetComputerName="Home Server">

    <!–  dim the Door Lamp and Desk Light on slowly and simultaniously  –>

    <insertScript runInNewThread="yes">

      <!–  dim the Bed Lamp on faster than the Bed Lamp  –>

      <zWave.slowDimOn module="Bed Lamp" durration="280" />

    </insertScript>

    <insertScript runInNewThread="yes">

      <zWave.slowDimOn module="Door Lamp" durration="120" />

    </insertScript>

    <!–  wait an hour and a half, then turn off all the lights  –>

    <waitFor seconds="5400" />

    <zWave.powerOff module="Desk Light" />

    <zWave.powerOff module="Door Lamp" />

    <zWave.powerOff module="Bed Lamp" />

  </webScripts.sendScript>

  <webScripts.sendScript targetComputerName="Desktop Computer">

    <!–  wait three minutes after the light dimming has begun, then play music  –>

    <waitFor seconds="180" />

    <openFile path="F:/music/playlists/Wake Up.wpl" />

  </webScripts.sendScript>

</roomieScript>

   1: //needed for printf()

   2: #include <stdio.h>

   3:  

   4: //needed for strlen()

   5: #include <string.h>

   6:  

   7: // prints the contents of memory in hex and ascii.

   8: // starts at the location of the pointer "start"

   9: // prints "length" bytes of memory.

  10: void Print_Memory(const unsigned char * start, unsigned int length)

  11: {

  12:     //create row, col, and i.  Set i to 0

  13:     int row, col, i = 0;

  14:  

  15:     //iterate through the rows, which will be 16 bytes of memory wide

  16:     for(row = 0; (i + 1) < length; row++)

  17:     {

  18:         //print hex representation

  19:         for(col = 0; col<16; col++)

  20:         {

  21:             //calculate the current index

  22:             i = row*16+col;

  23:             

  24:             //divides a row of 16 into two columns of 8

  25:             if(col==8)

  26:                 printf(" ");

  27:             

  28:             //print the hex value if the current index is in range.

  29:             if(i<length)

  30:                 printf("%02X", start[i]);

  31:             //print a blank if the current index is past the end

  32:             else

  33:                 printf("  ");

  34:             

  35:             //print a space to keep the values separate

  36:             printf(" ");

  37:         }

  38:         

  39:         //create a vertial seperator between hex and ascii representations

  40:         printf(" ");

  41:  

  42:         //print ascii representation

  43:         for(col = 0; col<16; col++)

  44:         {

  45:             //calculate the current index

  46:             i = row*16+col;

  47:             

  48:             //divides a row of 16 into two coumns of 8

  49:             if(col==8)

  50:                 printf("  ");

  51:             

  52:             //print the value if it is in range

  53:             if(i<length)

  54:             {

  55:                 //print the ascii value if applicable

  56:                 if(start[i]>0x20 && start[i]<0x7F)  //A-Z

  57:                     printf("%c", start[i]);

  58:                 //print a period if the value is not printable

  59:                 else

  60:                     printf(".");

  61:             }

  62:             //nothing else to print, so break out of this for loop

  63:             else

  64:                 break;

  65:         }

  66:         

  67:         //create a new row

  68:         printf("\n");

  69:     }

  70: }

  71:  

  72: // Prints the contents of memory in hex and ascii.

  73: // Prints the memory between and including the

  74: // two "end1" and "end2" pointers.

  75: void Print_Memory(const unsigned char * end1, const unsigned char * end2)

  76: {

  77:     if(end2 >= end1)

  78:         Print_Memory(end1, end2 - end1 + 1);

  79:     else

  80:         Print_Memory(end2, end1 - end2 + 1);

  81: }

  82:  

  83: int main(int argc, char **args)

  84: {

  85:     const char start [] = "hi there!  You're looking at me in memory!";

  86:     const char * end = start + (int)strlen(start);

  87:  

  88:     Print_Memory((unsigned char *)start, (unsigned char *)end);

  89:  

  90:     return 0;

  91: }

I’ve compiled this code with both g++ and Visual C++.

download here

Here is the program’s output:

68 69 20 74 68 65 72 65  21 20 20 59 6F 75 27 72  hi.there  !..You'r
65 20 6C 6F 6F 6B 69 6E  67 20 61 74 20 6D 65 20  e.lookin  g.at.me.
69 6E 20 6D 65 6D 6F 72  79 21 00                 in.memor  y!.

Here’s a video:

YouTube link

Download DVD Cover Art Finder version 1.1.0.0 here

Download DVD Cover Art Finder version 1.1.0.0 (source code) here

This release of DVD Cover Art Finder includes the ability to save the list of DVDs as an HTML document for printing or posting on a website.  (I copied the HTML into a Facebook note to document my list of DVDs.)  In addition, now the user can right-click on an item in the list of DVDs to play the DVD, open the DVD’s folder, or delete the DVD.

This version also has the “Load Automatically” option for cover art disabled by default.  In using the program, that caught me up a lot.  It also has a few simple look-and-feel updates.  For example, the DVDs in the list of DVDs no longer display empty square brackets if the DVD has no disk label.

For more information about how to use DVD Cover Art Finder, check out the post about version 1.0.0.0.

Download DVD Cover Art Finder version 1.0.0.0 here

Download DVD Cover Art Finder version 1.0.0.0 Source Code here (open with Visual C# 2008 Express)

This usage tutorial begins with the DVD already properly ripped to the hard drive.  I’ll have to make a tutorial about how to do that later, but for now you could use the tutorial that I used to learn how to do that. (link)

First, download and open DVD Cover Art Finder, duh! (note that I made two minor changes to the program since I did the tutorial.  Can you spot them?)

Next, click “Scan for DVDs”.

Select the folder where you store all of your DVDs and click OK.

Select the DVD of which you want to get cover art.  (notice how the DVDs that lack cover art show up at the top of the list.)

Be patient, and DVD Cover Art Finder will show cover art, which is currently picked from Amazon.com.  If the right cover art doesn’t show up, edit the Title text box and click the “(re)load coverart” button.

Click the cover art that looks right.  This will put the cover art in the image box in the Selected DVD group box and update the Title text box with the title of that DVD.

Edit the title box if necessary.

Click the “Save” button.  This will save the cover art to the DVD’s folder, as well as rename the DVD’s folder to match the title.  Saving also creates a data file to keep track of the information and places that in the DVD’s folder.

Great!  Now the DVD shows up in Media Center with the right title and cover art.

I hopped to get it out today, but that will have to wait until tomorrow.

Here’s a quick jump forward to the final product:

 Amazon has a great set of web services available from aws.amazon.com, and one of the services enables integration with Amazon’s online store.  Best of all, the sample code was written in C#, which is my programming language of choice.  The API itself is very easy to use and quite powerful, but enough of that.

My program, which I quickly decided to call DVD Cover Art Finder (very creative), uses the Amazon Associates Web Service to suggest 6 possible cover arts.  When the user selects one of the choices, the selection is shown in the bigger image box, and the dvd title is updated to the title as listed on Amazon.  I added in a bunch of quick keyboard shortcuts to make the process go a lot faster, which I really needed since I used the software to get 200+ cover arts.  The program also renames the DVD’s folder to the DVD title, and preserves the DVD disk label and some other information in a data file that it keeps in the DVD’s folder.

As you can clearly see, I haven’t put much effort into polishing the product yet (note the window’s title of Form1).  Using it to get a bunch of cover art, however, the thing is stable.

I’ll be finalizing this at some point and publish it to my blog, including the source code.  For now just marvel. 

FYI, Media Center also supports three ways to display the DVDs.  The one previously shown is “View Large”.  This one below is “View Small”, and there is a third option that I don’t find very useful called “View List”.

Selecting a DVD shows the disk’s location and and bigger cover art.

Playing the DVD is exactly the same experience as playing a physical DVD, except there’s no disk.

Here is a screenshot of the FRI version 1.8.0.0 main window with no search filters applied.

Here I typed mario kart into the title search box.

Clicking onthe Advanced Search button gives the user more options.

For example, here is the result of an advanced search for all Super Nintendo and Nintendo 64 ROMs that are categorized as English or an unknown language and are a not known bad image dumps.

Sorting the results by community rating brings the some of the best ROMs to the top.  At the time of this writing community ratings only include some Nintendo Entertainment System, Super Nintendo, Sega Genesis games, however FRI checks for updates to the community ratings file every time it starts, and will automatically pull it from my web hosting and apply the changes if I make a new version available.

FRI can pull ROMs from multiple file locations.  This allows more flexibility to the user, and offers some very convenient solutions.  For example, a user may have a desktop computer with a large ROM library and a laptop computer with a small ROM library.  FRI allows the user to add the local and remote libraries (via network share) into each copy of FRI.  When both computers are on the same network, the user can then right-click on a ROM that is in his desktop computer’s local library and have FRI send a copy to his laptop computer’s local library.  While both computers are on the same network, the user could also select any ROM displayed and it would just run, regardless of the file’s location.  In addition, when the laptop doesn’t have access to the desktop computer’s network share, the user can hide all of the unavailable ROMs by doing an Advanced Search.

When FRI scans for ROMs it automatically picks out all of the ROM files and infers a lot of information about each ROM, including platform, language, image health, status in the public domain, region, and number of players.  The information is totally dependent on the contents of the ROM’s file path/name.  Below are the default Vocabularies that come with FRI, which are completely user-editable.

The most important (and most difficult) part about FRI is telling FRI what emulators use what platforms.  Note how the “Compatible Emulator Detected” column shows whether or not an emulator is configured to work with FRI for each of the known platforms.  For now users have to locate, download, and configure the emulators themselves (which is the status quo for most emulated gaming), and then tell FRI where each executable is and what platforms each emulator supports.  As FRI integrates more with my web hosting, I plan on having a simple selector to download, configure, and integrate emulators with ease.  The emulator lists would of course be updatable by me at will.

For more information about FRI, see entries about it on my blog.

Download FRI version 1.8.0.0 here

Thanks to FlotsamX for providing feedback as a beta tester, and Vimm for providing me access to his website’s user ratings.

Change log:

• New feature: FRI now automatically retrieves a “master database” from the web, which currently contains “community ratings” of some ROMs.
  
• The process of scanning for ROMs is more responsive and provides the user with more information.
   
• FRI can now handle ROM files that have filenames that are too long.  Previously FRI would simply skip over these.  The user is now warned when a ROM with a really long file name is added.
  
• Generic file extensions are no longer attached to specific platforms.  That functionality never made sense, because they were generic file extensions.  Now generic file extensions are one list, available on the new "Other" tab of the Settings window.  The "Generic Extensions" column in the Platform Vocabulary list has been removed, and the other column widths have been increased to fill the space.
  
  
• ROM files that are executable (with .exe extensions) will now be run directly.
• The “Advanced” item in the “Edit” menu is now hidden.
• Fixed UI problem in the Platform Information Editor, where the "Cancel" button would not move properly when the window was resized.
• Fix: FRI no longer makes the “you can’t do that” sound when the user presses enter in the search box to start the search.
• "Other" tab added to the Settings window.
• Fix: The “defaults” button for the File Flags Vocabulary tab in the Settings Editor now works properly.
• "rom" added as a generic ROM file extension
• The "Unique Extensions" column in the Platform Vocabulary list has been renamed to "Unique File Extensions".
• ".a26" unique file extension for the Atari 2600 corrected to remove the decimal point.
• "Atari" removed as another name for "Atari 2600"
• Platforms added:
  1. Amega
  2. Amiga CD32
  3. Atari 7800
  4. Neo Geo
  5. Neo Geo CD
  6. Neo Geo Pocket
  7. ColecoVision
  8. Vectrex
  9. Magnavox Odyssey
  10. Magnavox Odyssey²
  11. SuperGrafx
  12. TurboGrafx 16
  13. Game & Watch
  14. Pokemon mini
  15. N-Gage
  16. 3DO Interactive Multiplayer
  17. Sega Dreamcast
  18. Sega CD
• Platform extensions added
  1. "col" added as a unique extension for "ColecoVision"
  2. "vec" added as a unique extension for "Vectrex"
  3. "min" added as a unique extension for "Pokemon mini"
  4. "vb" added as a unique extension for "Virtual Boy"
  5. “mdf” added as a generic extension

“Sony PlayStation”, “PSX”, “Sony PlayStation 1”, “Sony Play Station”, and “Sony Play Station 1” added as other names for “PlayStation”

I literally just got this working, but I’m really excited with the results.  I’m going to have to work on polishing the process a little more, and develop a method to deliver the “master database” containing the community ratings.  The delivery mechanism will also be expandable for me to add more data in the future, such as links to game manuals and walkthroughs.  That’s in the future, though.  For now I’m just glad for a little success!

Flotsam’s email address: (yes, the text is a picture.  I don’t want him getting automated bot spam!)

Now for the release.  FRI version 1.7.0.2 contains updated to the default Platform Vocabulary, as well as a fix to a bug that I will describe in detail below.

Download FRI version 1.7.0.2 here

To get the updates to the Platform Vocabulary, open the Settings window, click on the "Platform Vocabulary" tab, click the "Defaults" button, and click OK on the dialogue box.  This will overwrite your current platform vocabulary with the new defaults.

Change Log:

• "Compact Disc Interactive" added to the Platform Vocabulary, with "CDi" and "CD-i" as other names for the platform.
• The GameCube entry in the Platform Vocabulary was updated to make change the display name from "Game Cube" to "GameCube".  Variations of the name were added as other names, such as "Nintendo GameCube".
• The extension "gcm" was added as a unique extension for GameCube in the Platform Vocabulary.
• "Xbox" added to the Platform Vocabulary.  Variations of the name (including "Microsoft Xbox (original)" and "Xbox 1") were added as other names
• Bug Fix: In previous versions of FRI, file extensions were case sensitive.  That would mean that if, for example, a ROM was called "game.GB"  it would not be recognized even though "gb" was listed as a ROM extension in the Platform Vocabulary.  This problem is fixed in this release.
• Bug Fix: Previous versions of FRI would include the ROM database in the Default Settings File created by "Edit"->"Advanced"->"Generate Default Settings File".  This feature is only used in developing FRI, so it didn’t affect users.  At any rate, the bug is fixed in this release.