Microsoft .NET Micro Framework Tools & Resources

English (United States)

čeština (Česká republika)

English (United States)

HomeAbout the frameworkHardwareHow to startFAQExamplesArticlesUtilitiesE-shopLinksEventsContact

Here are the utilities which were available for download. I will organize it a bit here when I'll have time to update them.

Micro XAML Tool

Update 12/07/2008: Handlers are now being expected in the root class (they were expected on the objects which defined the event). Re-registration is not needed, just rewrite the current exe file.

Sure, writing an user interface in code is not a problem. Actually, every good WPF developer should know and understand the code which XAML describes. However, it ofen means lots of code lines, and every help counts. How would you like to write the UI using XAML, including intellisense support?

Okay, enough speaking, you can download the package here (50 kB, ZIP). Installation steps:

1. This is a prerelase version and likely has bugs - you have been warned...
2. The main file is the MicroXamlTool.exe. Put it into any directory you would like to keep it in.
3. It is a custom tool, and as such it must be registered with the Visual Studio. The application can register itself automatically, if you run it as administrator without parameters:
   
   (note: you can unregister it by running it again)
4. All five schemas (the files with a .xsd extension) need to be placed in the appropriate Visual Studio folder, typically C:\Program Files\Microsoft Visual Studio 9.0\Xml\Schemas. These files provide the intellisense support.
5. Move the packed Micro WPF Window.zip archive as it is into the item templates folder, typically C:\Users\You\Documents\Visual Studio 2008\Templates\ItemTemplates. This file is the standard template for new microxaml files (see the code on first screenshot) - you will see it in the project's add new item dialog:
   

And that's it! How to try it:

1. Run the Visual Studio and create a new Micro Framework project of Window Application type.
2. Add a new item to the project - in the My Templates group, choose Micro WPF Window.
3. Open the Program.cs and change the line number 16 to:
   Window mainWindow = new Window1();
4. Run the project. You should see a yellow window with Hello World! text in it.
5. If you change the type of mainWindow to Window1, you can directly access the named controls: mainWindow.MyLabel1 and mainWindow.MyLabel2.

Known limitations, planned to be resolved:

• The included schemas are first sketch only. For example, they do not cover explicit properties, although they are supported (eg. <Text.TextContent></Text.TextContent>), do not check value types, do not list all colors available etc. Stay tuned for schema updates and the schema generation tool, too.
• Attached properties are not supported yet. So you can't specify Canvas.Top="15" etc.
• Only x:Class and x:Name are supported from the xaml namespace at the moment.
• No markup extensions neither value converters are supplied now.

Some cool stuff:

• You can use any color string supported by desktop WPF where Color, Brush or Pen type is expected.
• Actually, the MicroXamlTool is able to instantiate any public object with parameterless constructor, not only WPF things.
• Although you cannot change the generated class' constructor, it contains a partial method OnComponentsInitialized, so you can just declare the other part:
  public partial class Window1 { partial void OnComponentsInitialized() { // your constructor code goes here } }
• As you can see from the default template, you can use resource names for values of type Font and Bitmap.
• You can attach event handlers as usual, though you have to declare them yourself in your part of the partial class.

Known limitiations which you'd rather get used to:

• Only objects from project's referenced assemblies are supported.
• You cannot instantiate nor access objects directly declared in your project.
• The Navigate to Event Handler command is not available in XAML.

Have a fun and let me know about any questions or issues!

Tiny Font Tool GUI

Update 7/30/2008: 1.1.0.0 Allows you to generate multiple bits per pixel fonts, but can't show them in the preview yet. Fixed bug of not passing QA and PF settings to the definition file. UI changed to match 96dpi and remembers last window size and position.

This tool could save you some time when dealing with TFConvert.exe. It is a graphical user interface for this font creating tool:

This application requires the .NET Micro Framework SDK to be installed, or at least TFConvert.exe accessible, in order to create .tinyfnt files. Otherwise all it can do is to create the .fontdef definition for you.

Compiled tool is available here (86 kB, ZIP) - for .NET Framework 2.0.

I will give source code to anyone who asks by e-mail.

Current biggest limitations:

• Only installed fonts supported (AddFontToProcess not utilized).
• Entering characters or character ranges using Unicode codes not supported.
• Reported metrics do not match exactly the metrics used by TFConvert.exe.

Advanced Emulator

Due to deep changes I doubt this version works with the 3.0 version.

Extensible emulators are one of the fundamentals parts of the .NET Micro Framework. In real world, every device manufacturer can very easily create an emulator for his device. Easily means either by XML configuration of the built-in Microsoft's emulator, or by making a Windows Forms application, which represents the device interface (as you can't add buttons using pure XML) and then connecting it with emulator components.

As for the Microsoft's built-in emulator, it has a 320x240 display and four pre-assigned buttons. This configuration is good enough for testing screen-saver-like applications, but you likely have higher aims. The worst thing on this emulator is, that it does not display any outputs, and it ends up with an error if your application uses any of the serial interfaces.

I've tried to address these issues using this, a little bit universal, emulator:

I was told that any atempt to create an device-independent emulator is a waste of time, so check it yourself, if it helps emulating your applications a little bit more than the built-in emulator - or even the emulator from device vendor - and let me know what do you think about it.

First, a little bit of propagation:

(1) The built-in display has 240x320 resolution. You can't rotate it by means of XML configuration (yet), neither you can change its physical dimensions now. However, any resolution you put into the XML will be stretched on the display surface, so that you can at least see the whole image.

(2) The list of currently used outputs and their actual state. The pin names can be dynamically read from any assembly specified in the XML.

(3) Outputs, in which you are interested during whole application lifetime, can be pinned. In this case, GPIO13 is checked in the Pinned items list, but has not been initialized yet by the application.

(4) Similarly all currently initialized inputs are available for control.

(5) And also outputs buttons can be pinned, as in this case of yet unitialized GPIO12.

(6) Significant amount of devices with UI will have buttons arranged in a similar way, and it's quite uncomfortable to control arrows using buttons in row, so I put few of them under the display in a fixed position. Pins which are they representing can be specified in XML.

(7) Input with glitch filter turned off is indicated by the exclamation mark.

(8) Pull-up and pull-down resistors are also indicated.

(9) As with GPIO ports, list of serial ports is available. By default, all of the ports available (i.e. defined in XML) are shown all the time. In addition, you can turn on automatic creation of new serial ports as requested by the application (COM ports only so far). In the case shown, an application for Meridian CPU is emulated, which uses some virtual ports.

(A) If you are developing an application which chats with several peripherals, but you don't have the peripherals available, or if you need to simulate a situation, which is not easy to set up on the peripherals, you can not only to monitor (and redirect) the communication, but also participate actively on both sides. For the present, only textual representation of the communication is available.

(B) Last, but not least, there is a FLASH memory usage indicator, showing different colors for different sectors usage. However, the current architecture of emulators does not allow to view the actual data stored in memory.

(C) You can save, load or erase the flash memory contents whenever you want. You can also set up an automatical memory save and restore to the disk in the XML configuration, so that your ExtendedWeakReferences are ready the next start.

In the configuration XML (AdvancedEmulator.exe.emulatorconfig) you can change the paths to the FLASH storage files and to the assembly, from which the pin names are being loaded. The default settings are storing the FLASH in the emulator folder and to not generate any pins, yet allow undefined ones. Examples to the Meridian and Microsofts enum are included as comments. Compiled - and not finished yet - emulator (debug configuration) can be downloaded here (ZIP, 332 kB). In order to use the emulator, you have to register it in Visual Studio. Extract the downloaded archive wherever you want and run the RegisterInStudio.exe (it registers the emulator to the framework version v2.0.3036; eventually you can register it yourself by writing to the registry as written in the RegisterInStudio.cs). The last step is to select Advanced Emulator in the your project properties.

I will give source code to anyone who asks by e-mail.

Warning:

• Designed on system running 120dpi. Neither .NET Framework nor Visual Studio does the scaling very well, so be prepared. I will try to fix this in next release. Segoe UI font comes in handy as well.
• The reflection is heavily used by the emulator to access undocumented parts of the .NET Micro Framework, so it can easily happen, that it won't work with any other version than 2.0.3036. (I'm testing with 2.5 version and it seems to work okay.)
• If your application reads data from a serial port, you have to set up its monitoring or redirection on the emulator prior to calling the Read method. I plan to add a default redirection setting to the XML in the future.

Fixes (thanks to Michael Schwarz):

• PinGenerator - in case you are not targeting any concrete hardware or do not have any custom classes from the porter, it was impossible to use PinGenerator to generate the pins from scratch. This was fixed and all what is needed now is <AllowUndefinedPins>True</AllowUndefinedPins>, eventually change the <MaxGpioPorts> value.
• PinGenerator - the GPIO_NONE pin is ignored now if in the enum of pins to load (so you can load Microsoft.SPOT.Hardware.Cpu+Pin now)

XML Documentation

This documentation is not recommended for 3.0.

The .NET Micro Framework assemblies do not contain XML documentation, which is useful when targetting memory constrained devices, but it makes learning of new technology quite more difficult. Fortunately, it is possible to link the XML documentation externaly. By rewriting the existing MSDN documentation to the XML format, you can get full Intellisense support in the Visual Studio:

Assemblies processed (as of 8.12.2007):

• Microsoft.SPOT.Graphics (76 kB, XML)
• Microsoft.SPOT.Hardware (51 kB, XML)
• Microsoft.SPOT.Native (80 kB, XML)
• Microsoft.SPOT.Net (13 kB, XML)

Keep in mind that MSDN is quite confusing in some places and not completed yet. The transcription was done during November and December 2007 and corrections (or new versions) are not included. XML files are in English.

To install this feature, download requested file or all together (27 kB, ZIP) and copy these XML files to the assemblies directory, i.e. most likely to \Program Files\Microsoft .NET Micro Framework\v2.0.3036\Assemblies.

As there were practically no changes in the 2.5 libraries, the documentatation is still applicable.