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.
The Chumby requires an external service to configure the modules.
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…
The framework
The WebUI and administration interface
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.
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?
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.
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.
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.
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:
Wiki page creation
Source control(?)
Modules:
Investigate the best way to load assemblies from SD card
Design an interface between the module and the framework
Design a filesystem for each module
Design a system to install, update and remove modules
Framework:
Investigate the best way to manage running assemblies
Investigate multitasking (maybe at framework’s sole discretion based on CPU use?)
Design a boot up system to take care of network initialization, NTP syncing, Persistant storage syncing etc
GUI design
WebUI:
Investigate whether it is too CPU intensive to run a web server always in the back ground
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).
GUI
Javascript, HTML and CSS development
Server side coding
SD Card:
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.
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.
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
