Main Site Documentation

Cobra "Chumby project"


So, I have always wanted something like a Chumby. Why not just buy a Chumby, you ask? Well, there are two aspects of the Chumby that drive me off.

  1. The Chumby requires an external service to configure the modules.
  2. The Chumby uses Adobe Flash. Ew!

In case you don;t know, the Chumby is like a digital clock – on crack. The device has a 3.5" touch screen with internet connectivity as well as a USB host and audio output. The idea is that you can install modules on the device to expand it’s functionality. Things like RSS readers, different kinds of clocks and audio players.

Now that the Cobra is around, I finally have the hardware to make my own sort of Chumby. The start of this is the software. Specifically…

  1. The framework
  2. The WebUI and administration interface
  3. The modules

The framework will be responsible for pulling all of the modules together, serving as sort of a back plane. The framework will be somewhat of an OS and should be able to override the modules at any time.

The WebUI will be used to configure the device and install modules. The WebUI may be a built-in module.

And finally, the modules. The modules will be the actual meat of the system. These will be stored on the SD card.

So, what does everyone think? I looked into it, and everything should be technically possible with the Cobra, although an SD card is going to be an absolute necessity to store the WebUI, modules and configuration files.

thoughts? Comments?


We actually contacted Chumby and have gone through the documentation thinking we put NETMF on a chumby because we like you idea. Now that we have FEZ Cobra, no need to port anythign to chumby.

By the way, we did some testing on chumby but it was not satisfying at all. Not to forget that you can’t add hardware to chumby like you do on cobra. The touch interface was just too slow. Flash is not really made to run on small devices I think.

Anyway, I absolutely love your idea…You can add twitter, shoutcast player and just too many fun things to this project.



What do you think of the whole modules on the SD card thing? Do you think that C# will be capable of managing the running modules?

The WebUI should be pretty simple since I’m a web developer, and the webserver should be just as easy to write. The modules should be pretty easy also. I think the really the only difficult part of this project is going to be the framework.

Can you offer any suggestions on how to write the framework? I’m no stranger to writing that kind of thing, just not in C# and not on .NETMF.

The other part is how to package the modules. I want them to be installed via WebUI, but this may only be viable once the project is going. Until then, they may just need to be installed manually by placing the files on the SD card.

A module package should include

  • An icon
  • A set default configuration options
  • The actual module
  • Hooks for the WebUI
  • Hooks for the framework

Oh also, need a cute name for the project. Any ideas? :confused:


Like the idea. :wink:

How about Numby or Numfy (.net mf chumby) :wink:


Loading assemblies from SD is possible but how to make whole modules? I am not sure what is the right way


Maybe make your own file format the contains all needed assemblies plus icon and other info.
You will need to write a pc software that generate all this


Well, one thing I could do is make a REST service for getting to modules. Maybe when you install a module, you only give the Netby (I kind of like that) an XML file with the URL of the module. The Netby then uses that URL to get a list of files and folders it needs and then downloads/creates them.

That way, I wouldn’t have to ever worry about file formats or anything. On the service end, I could make the web page accept zip files of a certain structure or something.

I like the idea of those. Maybe Netby? I’m not sure th MF could really fit in there wit out sounding weird.


Sounds exciting but are there any potential copyright / patent infringement ? If yes then refrain from using similar words , concepts etc.

I may be wrong on this but someone please do the neeeded.



I don’t think it is possible to have such a broad patent or copyright. The project will be named Netby, so no competition there and although the device does function similar, it is still different enough from a Chumby.


Well, I started coding a proof of concept for the whole “modules on the SD card” thing. I have been pretty much reverse engineering the extremely outdated project on the wiki (link removed).

Once I get that working, I will attempt to port over the Weather Clock application so that it can be loaded off of the SD card. If that works, I will begin development of the actual project.

Because this is so complex, I think a lot of it is going to have to be done in modules first to verify that all of this is technically possible – even though at least theoretically, it is.


Let me know how it goes i would like to work on this with you.


Ok, great! I’m going to finish the test program tomorrow to make sure that it’s viable to actually run things from the SD card. I think I might have you help to work out some of the details and write some more tests, EG, see how viable it is to run a webserver in the background at all times.

I think one of the biggest things is also seeing if .NETMF can run as a sort of OS. That, I’ll definitely need help on.

Anybody else want to pitch in?


Hi Chris

I would like to be a part of this too.

It would be nice if you could break down some of the requirements and list them as tasks. This way we can tag who is working on what and avoid duplication of effort.



Was just thinking…why not just include every single GHI/Microsoft assembly in your project? Then users can make their own widget, which will be one assembly to be loaded from SD card or USB drive.

Once the idea works out then you can start thinking about how users can make a widget that has multiple assemblies.


@ Gus: Yeah, that’s what I was thinking to. Hopefully the framework is small enough to allow for all of those assemblies in there.

As for tasks…

Immediate stuff:

  1. Wiki page creation
  2. Source control(?)


  1. Investigate the best way to load assemblies from SD card
  2. Design an interface between the module and the framework
  3. Design a filesystem for each module
  4. Design a system to install, update and remove modules


  1. Investigate the best way to manage running assemblies
  2. Investigate multitasking (maybe at framework’s sole discretion based on CPU use?)
  3. Design a boot up system to take care of network initialization, NTP syncing, Persistant storage syncing etc
  4. GUI design


  1. Investigate whether it is too CPU intensive to run a web server always in the back ground
  2. Design a highly extend-able way for the WebUI to communicate with modules (Remember, modules will come with WebUI hooks as well as HTML, CSS, and JS).
  3. GUI
  4. Javascript, HTML and CSS development
  5. Server side coding

SD Card:

  1. Create an installer to create the configuration files on the SD card and verify it is formatted correctly, etc.

So, like I said, the really difficult stuff is going to be in the beginning, figuring out if this is a worthwhile idea or not.

I’ll be pinging back here in a little bit (half hour maybe) when I get my initial test up an running. In the mean time, does anyone want to make a wiki page for this and start putting in other tasks they see as relevant?


Sorry for the delay, guys. Everything was going great until my friggin keyboard tray decided to collapse on me, taking my keyboard and mouse with it. This is a good reason why not to buy a glass desk from Officemax. There isn’t even a name on the desk for a company to ask for a new tray.

Off topic, but anyway, all the test code is done, at this point I am just figuring out the mechanic of how it works. I haven’t confirmed that it will work, but I’ll know that it in a few minutes.


Good news!

I got the run time assembly loading tests done, it works!!

Here is the code:

The next phase is to try and turn my WX Clock application into a reference and see if it will run. If that works, we are probably good to assume that this is possible.


Well, I tried to run a simple Window application from a referance, and I got this:

Assembly: Netby_Module_Clock ( needs assembly ‘Microsoft.SPOT.TinyCore’ (4.1.2486.0)
Assembly: Netby_Module_Clock ( needs assembly ‘Microsoft.SPOT.Graphics’ (4.1.2486.0)
#### Exception System.Exception - CLR_E_TYPE_UNAVAILABLE (1) ####
#### System.Reflection.Assembly::Load [IP: 0000] ####
#### Netby_SDLoadTest.Program::CreateWindow [IP: 0039] ####
#### Netby_SDLoadTest.Program::Main [IP: 0009] ####
A first chance exception of type ‘System.Exception’ occurred in mscorlib.dll
An unhandled exception of type ‘System.Exception’ occurred in mscorlib.dll

Any ideas?


Like I suggested in my last post, you must include all GHI and Microsoft in your core application.
Look at the error message gain, you will know what you need to add :wink:


That’s the problem, there were already added.

EDIT: I’ll publish my source code later today.