TinyCLR - .NET Micro Framework

New GHI blog is up

2011-02-19T05:25:00.001-08:00

There is an official GHI blog now so I will stop posting here and use the official GHI one instead. You can see the GHI blog here http://ghielectronics.blogspot.com/

Have fun and will see you at new blog!

Debug and deploy over serial

2010-03-12T05:45:00.000-08:00

All GHI's NETMF devices use USB for deploying/debugging by default. Optionally, a developer may want to use the USB client (not the host) for something other than debugging. This is actually supported by NETMF and GHI adds much functionality making it very easy to setup.

Let me give you an example, you are making a device that that reads temperature and humidity...etc. and logs all this data on an SD card. This device can be configured, like to set the time or give file names...etc. You want the device to be configured over USB. So when your device plugs into a USB port, you want it to show as a virtual serial port. This way, anyone can open a terminal software (like TeraTerm) to connect to your device to configure it.

Sounds good so far, but what device to use? This is an extremely simple application and it will fit very well on our smallest device, that is USBizi. Since FEZ boards use USBizi chipset, then I will use them for my project. FEZ Domino or FEZ Mini will do just fine.

http://www.tinyclr.com/hardware/1/fez-domino/

http://www.tinyclr.com/hardware/2/fez-mini/

The first thing we need to do is change the debugging interface to serial instead of USB. Again, that is because we want to use USB as a virtual serial port to set the configuration our project. USBizi has a pin that is called MODE pin. If this pin is high or unconnected then USBizi (FEZ) will use USB fro deploying/debugging (and for boot loader) but if the pin is low (connected to ground) then USBizi will be using its COM1 for everything.

FEZ Domino has MODE jumper (by the LED) , close this jumper to use serial. FEZ Mini, has MODE pin available on the SD header. The pin is next to ground pin so you only need to short MODE to ground.

Ok, now we have USBizi(FEZ) ready and it is using serial. Now, we have all setup but we still need to connect USBizi(FEZ) to the PC's serial port. The PC serial port is RS232 but the serial connection on USBizi(FEZ) is TTL.

To use FEZ Domino serial COM1 with a PC, you can use the RS232 shield.

FEZ Mini already have RS232 circuit on-board. To connect its RS232 pins to a PC, you will need to make some cable or an easier option is by using the RS232 cable we offer+the starter kit. We also offer a USB<->serial cable. Through this USB<->serial cable, you can debug using a virtual USB-serial connection. Which means, USBizi (FEZ) will be debugging over serial but you actually have a USB connection to the PC!! This is similar to connecting FED Domino RS232 shield to a serial <->USB cable.

When the setup is complete, try to "ping" the device using MFDeploy. Note that this time you will not select USB but you will select Serial. You also need to select the appropriate COM port.

Can BASIC run through C#? This is crazy!

2010-03-08T16:45:00.000-08:00

Do you remember BASIC on DOS? Maybe you are too young to know BASIC or DOS. Eitherway, you probably know what is BASIC because of the popular Visual Basic.

So GHI's .NET Micro Framework devices run C# code and can actually run Visual Basic as well. As of now Visual Basic support is not directly supported.
So, I was thinking...what if I can run a BASIC interpreter in C# to run BASIC programs? This will be interesting to see but in reality, this is absolutely pointless!
Think about it, you write program in BASIC then this get interpreted through C# which it turn is also interpreted through the CLR.

Even thought this is useless, I want to see if it can be done (was bored on the weekend!). So, I did some googleing and found a very simple interpreter written in C. I took that code and started converting it slowly to C#. I was able to get the commands PRINT and GOTO implemented along with support for labels. Adding the rest should be simple but I am stopping here since I have proven that my crazy idea can be done.

The project file includes my C# project and includes the original C files if you want to complete the port.

The project is available at http://www.microframeworkprojects.com/project/50

Using XBOX controller with .NET Micro Framework

2010-03-07T14:28:00.000-08:00

If you are asking yourself, how do I use the XBOX 360 controller in my project? If you are using Arduino then this requires so much circuitry and programming to do...actually, I am not sure myself how this can be done. If you are using BS2 then just forget about the idea! To use XBOX controller you will need a windows CE device with few month to learn how to write USB drivers. Out of curiosity, I did search the web for drivers for XBOX, linux winCE, windows or MAC drivers. I did find few and I can tell you this, looking the the driver source code was scary. Try to google then and take a look yourself.

XBOX controller has many digital inputs but unfortunately it is not a standard HID device and so it will not work with the standard drivers. This example implements an XBOX controller driver using raw USB services.

Thank god GHI offers a raw USB services that is available on all GHI's NETMF devices, including USBizi(FEZ), EMX, ChipworkX...

The example driver is available at http://www.microframeworkprojects.com/project/49

This is a simple driver that is meant to be as a starting point to show you how you can access almost any USB device, even the ones that are not directly supported.

// create a driver instance
XBOXController XBOX = new XBOXController();

// read the analog hat switch
Debug.Print("LH " + XBOX.GetAnalogHat(XBOXController.AnalogHat.LeftHatX) + " " + XBOX.GetAnalogHat(XBOXController.AnalogHat.LeftHatY));

// read digital switch
if( XBOX.GetButton(XBOXController.Button.X)) Debug.Print("X");

Note that writing USB drivers on GHI's devices is very easy but still requires some knowledge of the internals of USB. If you are using standard devices liek mouse, keyboard, storage then these have built in drivers, so you do not need to know anything about USB.

.NET Micro Framework SDK 4.0 is in beta stage

2010-02-26T15:40:00.000-08:00

The all new SDK for Embedded Master and USBizi is available for immediate download! ChipworkX come next and very soon.

With this SDK, all GHI NETMF products share the same SDK and same libraries, allowing seamless switching between all products, same code same project runs on any GHI NETMF device.

The forum includes some steps and details on how to install 4.0

Embedded Master: http://www.ghielectronics.com/forum/index.php/topic,2866.0.html

USBizi: http://www.ghielectronics.com/forum/index.php/topic,2865.0.html

This month will be exciting will all new updates...so stay tuned ;-)

Using TFT displays and standard VGA monitor with EMX or Embedded Master

2010-02-21T06:04:00.000-08:00

GHI Electronics offers many hardware modules running .NET Micro Framework, like EMX and ChipworkX. They all support TFT displays with 16-bit 5:6:5 RGB color depth.

With this interface, users can use about any TFT display. Some applications, like handheld devices, may require a 320x240 3.4" display. Others, like vending machines, may need a 640x480 7" displays. What about airport informational center? Those will probably need a 12" 800x600 displays. What is important is that GHI NETMF modules can work with all these options. Through a simple call to the GHI managed libraries, a user can set the default settings for display, including resolution, HSYNC, VSYNC and clock.

What if an application require to work with external VGA monitors? While TFT displays are rather flexible when it comes to timing and clock rates, VGA monitors must have a very precise clock. Since the image beam is controlled directly by the VGA signals, a high clock rate is required. A 640x480 @60hz refresh needs about 25Mhz clock! Stepping up to 800x600 @60hz will need 40Mhz! Having 40Mhz clock at 2bytes per pixel will require 80MegaBytes/second.

In computers, generation the clock is handled by the graphics card. All the processor have to do is transfer the frame buffer (image) to the graphics card then the card will take care of generation the clocks. On small embedded system, generation such high clocks/bandwidth is not an option.

Fortunately, there are small chips that does what graphics card do. Chrontel at www.chrontel.com offers a chip called CH7025 that has an internal 2MB for frame buffer. An embedded system, like ChipworkX, can send its buffer at any clock rate to CH7025 and then the chip will take care of generating the appropriate clocks. It even take care of converting the 16bit digital signals to the VGA analog colors Red, Green and Blue.

Here is the datasheet http://www.chrontel.com/pdf/7025_7026ad.pdf

The good news is that EMX and Embedded Master can generate VGA timings with some limitation. They support 640x480 resolution with actual 480x480 pixels. This means that the monitor will see a 640x480 clock timings but you will have actually 480x480 pixels to draw on. With this configuration, EMX and Embedded Master can generate the VGA signals without the need for any extra components. (Remember that you can use any resolution you like if you add a frame generator circuit.) Keep in mind that this requires these devices to transfer about 50MBytes/sec in which will slow down the system. This option is ideal for vending machines and informational centers.

OK, we are all set as far as timings. Now, we need to convert the 16-bit digital to analog signal. If perfect colors are not important in your device then this can be accomplished using simple resistor circuit. Here is an example schematics

http://www.ghielectronics.com/downloads/EmbeddedMaster/EM-VGAEXP_sch.pdf

With this simple circuit, you will still have perfect image quality but the colors will be slightly off. If you are displaying text or solid colors then images will look perfect. But, if you are displaying full color photographs, then images will look okay but not perfect. To prefect colors, we need to use a DAC chip.

Here is a video of a customer talking about generating VGA signals.

This is a fun time-laps video of the same customer assembling a circuit that host Embedded Master. Time-laps starts about in the middle of the video.

Where is NETMF 4.0? What is new?

2010-02-20T06:28:00.000-08:00

The new release of .NET Micro Framework 4.0 is very compatible with 3.0 so updating the firmware is somewhat an easy task. GHI Electronics took this opportunity to rewrite and optimize the whole driver set for USBizi, EMX (Embedded Master) and ChipworkX.

What does that mean to you?

All managed libraries are now uniform among all products. If you have code for EMX then it will simply work on ChipworkX with no changes.
http://ghielectronics.com/downloads/NETMF/Library%20Documentation/Index.html
Optimizing allowed us to *double* the free memory on USBizi chipset, was about 20K and now about 40K. This means NETMF C# projects can run smoother and users have higher flexibility.
USB Host now supports unlimited USB devices! This new support works on all our devices even USBizi. You can now connect hubs/devices anyway you like and they will all work simultaneously.
All GHI NETMF SDKs are now combined into one download. This make sense since all are now sharing the same managed libraries.
The same EMX firmware will also run on Embedded Master. Loading 3.0 on EMX will not work and will damage EMX but the new 4.0 firmware works fine on Embedded Master and EMX.

Keep in mind that if you are using one of our modules/chipsets then these updates come free to you! You only need to download the firmware from GHI website and load it on your device.

The schedule:

USBizi 4.0 has been out for months where it was used on FEZ. If you didn't know FEZ actually has USBizi chip on it so FEZ=USBizi (see www.TinyCLR.com). We didn't announce the firmware for USBizi because we wanted to modify few things first. By the time you read this post, USBizi 4.0 release should be online. We are done but still doing some extensive testing
The new EMX is online (and in stock!) but can't be ordered till March 1, 2010. By then, the 4.0 firmware for EMX and Embedded Master will be online.
ChipworkX comes last to join in the 4.0
In short, a production release firmware will be available for all our NETMF products by end of March 2010 but beta will be available in beginning of March.

We very much value your feedback so please let us know what you like/dislike and help us out in testing the all new 4.0 firmware.

FEZ the movie and what is FEZ Monkey?!

2010-01-26T07:47:00.000-08:00

It is amazing to see what "FEZ" search will result in....found this FEZ clip on Youtube!

According to Urban Dictionary, "FEZ Monkey" is the highest level of being, the highest point of evolution. Only a select few ever make it to this.

FEZ...the easiest way to go embedded!

2010-01-16T10:02:00.000-08:00

FEZ Domino and FEZ Mini are very small (open source) boards targeted for beginners. They are based on USBizi chipset and so they have all USBizi features. Those little boards offer a lot of peripherals not available with any hobby-targeted board. Even tough it is targeted for beginner, it is a low-cost starting point for any professional wanting to test out NETMF.

FEZ stands for "Freakin' Easy!". See more at http://www.tinyclr.com/

Features available in FEZ but not available in Arduino, BASIC STAMP and others:

Based on Microsoft .NET Micro Framework.
Support runtime debugging (breakpoint, variable inspection, stepping...etc.)
Uses free VS2008 C# express edition for development.
High-end features like FAT, threading, USB device and USB host.
Hardware independent. Easily upgrade to more fancy hardware like ChipworkX.
Open source hardware design files.
Already available shields and holder boards.
Based on USBizi chip. Use the chipset to create new designs.
FEZ Mini comes alone or bundled in different kits forms, like the starter kit and the robot kit.
There are tens of sensors that are ready to plug directly into the kits. From LEDs and buttons to reflection and temperature sensors. Many projects can now be completed with NETMF without the need for any soldering.

This is a video showing FEZ Mini Sytarter Kit and an example on how to add components.

Not sure how to get started? These three videos will show you the way.

Video Playback on Micro Famework using RLP - last part!

2009-10-17T13:14:00.000-07:00

This took a while for me to post...sorry, I have been very busy! Which worked out very well because GHI made some enhancements on RLP. Now, there are extensions available that give access to the system resources, for example malloc and free. In my example, I use my own malloc and free because if I do something wrong or cause memory leakage, it will only harm my own RLP but not the system plus I wanted to prove that it is possible to have our own memory allocation in RLP. I am still using the delay extension in my code. When I ran it the first time it was too fast so I had to slow it down!!

So to play a video, first you have to remove the audio from it like I described before. Then place the video on the internal flash of ChipworkX. In latest firmware this flash is accessible from windows, just like any external media so just drop the video there! I also put the libmpeg elf file right in the internal flash. This allwed me to update libmpeg library by simply changing elf file on the internal flash.

You can use this elf file in any project but to compile the elf file there are many things they you will need. I do not explain it because it is just too much work. I will clean up the project and make it compile easily with YAGARTO, like other RLP examples in SDK. This will happen when I have some free time...if I ever will!!!

So, if you have ever thought that .NET Micro Framework is slow or not real time then think again! With RLP extensions from GHI Electronics, you can now run time critical procedure VERY fast through native code. www.chipworkx.com

Here is the project with details and source code

http://www.microframeworkprojects.com/project/41

Free .NET Micro Framework and C# Book

2009-09-25T11:47:00.000-07:00

.NET Micro Framework is a great technology but many developers are afraid to use it because of the lack of beginner tutorials. I though it would be very helpful if I write a beginner book for NETMF and for C#.

Funny story, a GHI customer who happen to have PhD degree on engineering found it difficult to find info on how to blink an LED! I completely understand as I did struggle the same way at the beginning to learn about the simplest details of .NET Micro Framework.

.NET Micro Framework is extremely easy compared to other embedded solutions but we are missing a beginner book, well you have it now. The book also covers C# so you actually have 2 books in one....and it is free download!

Do not forget to see all the projects on GHI's projects website

http://www.microframeworkprojects.com/

The book is in progress but it already includes everything you need to get started

http://www.ghielectronics.com/forum/index.php/topic,2408.0.html

ChipworkX just got even better! Mass storage and enhanced RLP

2009-09-25T10:39:00.000-07:00

The latest release of ChipworkX adds mass storage device support. When you plug in the USB cable from ChipworkX, Windows will now see a mass storage device (internal 256MB flash) and will also see the debug interface.

Not only that, GHI have also added new "extensions" to RLP allowing user to use some predefined code like set/clear pins and malloc/free memory. New RLP also supports installing interrupt handlers. Your NETMF project can now handle interrupts in real time.

The SDK also includes examples on how to use "make" to create RLP files very esily using free GCC compilers.

I had stopped progressing my tutorial on Video playback using RLP because I learned about all teh cool things being added to it but now with new SDK, I will go back and revisit the video playback using the new RLP support.

This ChipworkX firmware is still in beta but it is very close from what the RTM will look like.

Embedded Systems the Micro Framework way!

2009-09-01T07:23:00.000-07:00

GHI products with .NET Micro Framework greatly reduce time-to-market for most designs. Hardware and software can be accomplished with an ease and a peace of mind.

This great video shows how much you could do with a very short time when compared to conventional design strategies.

WiFi is now available on .NET Micro Framework devices

2009-08-31T15:08:00.000-07:00

GHI proudly announces the first .NET Micro Framework 3.0 hardware to run WiFi 802.11 wireless networks on ChipworkX and Embedded Master.

This new feature supports WEP, WPA, WPA2 secure networks through hardware AES and RS4 cyphers.

The wireless 802.11 hardware module is FCC, IC and WiFi certified and costs only about $30 in low quantities which makes it ideal for .NET Micro Framework devices.

Embedded Master and ChipworkX with Power over Ethernet

2009-08-14T07:41:00.001-07:00

In Some applications, a networked device can be placed at a distance connected to an Ethernet cable. It would be really beneficial if the Ethernet cable can be used for data and for power. You actually can do that. This is called "Power over Ethernet", PoE for short.

There are many options for PoE. The easiest way I found (and cheapest) is by using a pair of splitter/injectors.

A .NET Micro Framework device like Embedded Master and ChipworkX can easily be power and networked using the same cable.

In this picture, you can see ChipworkX power and connected the laptop for networking using the same Ethernet cable.

This website offers those cables for about $3.

http://www.andahammer.com/poeispair

Additional offers for the Dare to Dream Different contest

2009-08-10T12:18:00.000-07:00

GHI Electronics, LLC is giving away 100 coupons and free consulting hours to Dare to Dream Different contestants. Winners and even non-winners still get coupons!

Coupons and consulting hours are provided as follows:

1,000.00 USD coupon plus 20 consulting hours for each one of the 2 first place winners.
500.00 USD coupon plus 10 consulting hours for each one of the 4 winners of second prize.
250.00 USD coupon plus 5 consulting hours for each one of the 2 who made it to final stage but didn't win.
100.00 USD coupon for the 90 contestants who didn't make it to the final round.
An additional 100.00 USD coupon is provided if the contest project is tested on GHI products and submitted to http://www.microframeworkprojects.com/

Total estimated value of all prizes is 26,500.00 USD.

Rules:

Coupons are valid for one purchase, directly form GHI Electronics, LLC.
Coupons can not be redeemed for cash.
Coupon can not be applied to previous order(s).
Coupons are valid only for a purchase of USBizi, Embedded Master, ChipworkX and their sub products.
Coupons can't be used for shipping/handling fees.
Consulting hours can be used for one .NET Micro Framework related project only.
Coupons and free consulting hours are valid till November 1, 2009.
Support is always free and unlimited http://www.ghielectronics.com/forum/
GHI Electronics, LLC reserves the right to alter these rules and offerings.
Names of contestant must appear on the contest page
http://dreamdifferentcontest.com/round1_winners.aspx

To use the coupons, please contact GHI directly through phone, fax or email.
http://www.ghielectronics.com/contact

Video Playback on Micro Famework using RLP - part 2

2009-07-27T09:57:00.000-07:00

So, ready for video playback? I know I am but there are more things to prepare first!

libmpeg2 library supports video mpeg files. Most video files will have video and audio. Those files are saved as program stream or transport stream. libmpeg2 includes an example on how to parse the audio/video stream to get the video out but, for simplicity, we will use a video only files....at least for now.

Another thing to consider is the video size. You probably want it to be the LCD size or smaller. 320x240 is very common size. To convert the videos, I use a free open-source WinFF from http://www.winff.org

With WinFF presets, I created my own preset and called it ChipworkX and used these settings

-f mpeg1video -an

With those settings, I removed the audio and used MPEG1 encoding. MPEG2 is also supported but it requires licensing so we will use MPEG1. You can now convert almost any video file to MPEG1 file with no audio. Remember to set the video size to something small, 320x240 or smaller.

Understanding RLP

The RLP feature form GHI allows developers to load and run ELF files at runtime form within Micro Framework. There is 2MB in SDRAM reserved for this purpose. They can be used for code, data, heap ...etc. The stack will be shared with the main system stack. ARM processors handle stack through hardware registers and it defines the procedure calling convention. This allows mixing different compilers. For example, Micro Framework is compiled using RVDS from ARM but you can load an elf file that was compiled with GCC!

The next step is to compile libmpeg2 in a separate project and test it out using JTAG on ChipworkX. Micro Framework is not needed at this point but we will still use the 2MB reserved for RLP at 0x23D00000. (update: This address changed to 0xA0000000...see ChipworkX documentaion)

Now we need to expose some functions out as RLP so we can call them from within .NET Micro Framework. All exposed functions must be in the form

int Foo(unsigned int *generalArray, void **args, unsigned int argsCount, unsigned int *argSize);

Those exposed functions are called from Micro Framework using Invoke() method

int Invoke(uint [] generalArray, params object [] argList);

You probably guessed it right! The return type and generalArrray are same on managed and native sides. The argList in managed code is translated into an argument list pointer array args. argsCount will help in debugging and it is the count of how many arguments passed. If none is passed then it is zero. argSize helps is knowing the size of the passed argument. For example an int will result in 4. It is mainly used with arrays so we can know how large is the array and go out of boundary.

Note that passing arguments in argList requires some overhead and a copy of the data is passed down to the native side. An exception is when using byte arrays which are passed as a pointer and have very little overhead. This is perfect for our example here o pass down the video data for decoding.

The first argument argList will always exist on C# managed code. This int array is passed as a pointer and done with least overhead for speed. Changes on values in native code will also change the values on managed code. If this argument is not needed then NULL can be passed from C#. We will be using this in some of the methods.

Looking at how libmpeg2 functions, I needed 4 RLPs for this example:

RLP_MPEG_InitializeRuntime (setup the C runtime, like heap and rodata...etc.)

RLP_MPEG_Init (initialize libmpeg2 and allocate and object for decoding)

RLP_MPEG_Decode (run the decoder loop)

RLP_MPEG_SendBeffer (pass more video data when requested by decoder)

.......Stay tuned for part 3.........

Video Playback on Micro Famework using RLP - part 1

2009-07-22T11:14:00.001-07:00

Since .NET Micro Framework is targeted for little processors, video playback is not supported. But with processors becoming more powerful and costing less everyday, existing Micro Framework devices can very well run video streams. Take for example ChipworkX. It is based on a 200Mhz ARM9 processor which is capable of running WinCE or Linux so why not playback a video?

Click here for ChipworkX page

Micro Framework core doesn't support video playback. The best you can do is play an animated GIF or a MJPEG (Motion JPEG) file with some parsing but with that, you will get about 1 frame per second...very slow!!

http://en.wikipedia.org/wiki/Motion_JPEG

So, the only way to decode a video stream in real-time is by doing it natively (C/assembly). This requires porting kit and adding some interops to Micro Framework. This means you need to know a lot about Micro framework internals and you are able to compile the whole Micro Framework system (compiler config, JTAG loading, hardware...etc.) Thanks to RLP, you do not have to go through this route.

With new RLP (Runtime Loadable Procedures) from GHI, you can load your own Native executables without knowing anything about Micro Framework internals! This is similar to loading DLLs on Windows. Although RLP run through Micro Framework, they run about 10,000 times faster than managed code!

Through this blog, I will show you, step-by-step, how to create and RLP that plays MPEG video back on ChipworkX. This info will help you understand RLP and will show how powerful it is.

I will be using GPL libmpeg2 library to decode an MPEG. The MPEG file will be loaded from a USB memory drive.

Click here for libmpeg2 homepage

Stay tuned for more.....

Share your Micro Framework Projects and save!

2009-07-07T11:03:00.000-07:00

For all .NET Micro Framework lovers!

We love this technology and we think it will change the way we think
"embedded". Many developers still do not know about the amazing things they
can do with Micro Framework. So.....
GHI has created this project website for everyone to share their projects
and learn from other's.
www.tinyclr.com (or www.microframeworkprojects.com)

For limited time, we will give you $50 off your next order for every project
you upload!
You can use *any hardware* you like including, ChipworkX, Embedded Master, CANxtra,
USBizi, TahoeI/II, AUG AMI DevSys or others!

Rules:

Uploaded project must be yours and the project must be complete (image/code/description)
Uploaded project must be useful to other users, see website for example projects. (blinking LED is not really a project! :) )
$50 applies to orders of $150 or more ($150 not including shipping)
Your project must be new and uploaded after 7/7/2009 (updating old projects do not apply)
You can use any Micro Framework hardware from any company you wish (not required to use GHI products!)
This promotion is available for limited time only no matter when the project is uploaded
The $50 coupon is valid for 30 days from the day you upload a project
Only one discount per order. If you upload 2 projects then you get 2 discounts but on 2 separate orders

How to order:

upload your project
send us the order form (no online orders and no distributor orders) http://www.ghielectronics.com/downloads/GHI%20order%20form.pdf
include your project name
we will contact you back with approval of $50 off once we check and approve your uploaded project

GHI Team
www.ghielectronics.com

Protecting managed applications

2009-05-16T12:08:00.000-07:00

Is my code secure?
One main issue that software companies face is protecting their code from piracy or reverse engineering. When writing code that compiles to assembly language, revers engineering the code is very difficult but that is not the case when using managed programming languages. When developing an application for Micro Framework, the code is compiled into an assembly that be easily reversed by free tools!
Take a look at http://www.red-gate.com/products/reflector/

Signing Deployments
Micro Framework tools allow signing application files so only you can load files on your application but your application is not secure at all. Anyone with MFDeploy can read the complete deployment region.

Protecting assemblies on Embedded Master
There are 2 problems that needs to be covered. First, we want to protect the deployment region. GHI Micro Framework extended library adds a call to protect the deployment region from being accessed on TinyBooter. This blocks MFDeploy from using the device.
SystemManger.ProtectFirmware(...)

The second issue is in protecting the files sent to end customers for firmware infield updates. This is resolved by GHI's SystemUpdate class. This class allows the hardware to update itself! Here are some simple steps to load encrypted application on the device.

Releasing new encrypted application:

Develop an application
Create application deployment using MFDeploy
Encrypt the deployment file (probably using XTEAM since it is already included in Micro Framework)
The encrypted file can now be sent to the device using Internet or load it from a media (SD card or a USB memory drive)

Loading the encrypted application:

The hardware should be designed with update capability that is based on GHI Embedded Master's SystemUpdate class.
Reboot the system using SystemManager.RebootMode method to enter update mode
Start loading the encrypted application (from Internet or media) and decrypt in memory
Pass on the decrypted application to SytemUpdate.WriteFirmware. Note that this will not write any memory but only buffer the data aside.
When all firmware is complete, call SystemManager.StartUpdate method. This will update the necessary flash blocks. In couple seconds, the device will reset and boot the new firmware.

This is a link to the GHI library reference
http://www.ghielectronics.com/downloads/EmbeddedMaster/LibraryDocumentation/Index.html

For further assistance, please use the GHI forum
http://www.ghielectronics.com/forum/