What is FEZ?

FEZ (Freakin' Easy!) is a ciruit board based on USBizi (EMX for FEZ Cobra) running the Microsoft .NET Micro Framework at the core. It is targeted for electronics beginners, hobbyists and even professionals. We enclosed everything, hardware and software, in one package for an easy and fast start with .NET Micro Framework and embedded systems. With .NET Micro Framework, developers can write code with greater efficiency using C# programming language under Microsoft Visual Studio. Many libraries for hardware and software access are already available with FEZ including FAT file system, threading, UART, SPI, I2C, GPIO, PWM, ADC, DAC and more.

I want to try before I buy. Can I use an emulator?

NETMF includes an extensible emulator that you can try right now, without owning any hardware. Actually, our tutorial shows you how to run your first application on the emulator before you run on the real hardware.

The NETMF emulator comes with source code showing how to extend the emulator to fit your needs. For example, you can change the skin to make the emulator look like your end products. You can even map buttons and change the display resolution.

Note that the emulator only emulates the core services of NETMF and it doesn't emulate GHI's exclusive features, but you have the option of adding them. For example, simulating CAN messages wouldn't make sense unless you know exactly what you want to simulate in your end device. The emulator should also be made to emulator your own product instead of emulating the GHI chips/module, so the emulator is more useful. This is why we leave the emulator up to you, to make and configure anyway you like.

How does FEZ work? Is it fast?

.NET Micro Framework is a very large set of libraries and a core CLR (interpreter). It is actually amazing that GHI was able to fit it all on a single chip! When you write an application in Visual Studio and run it, Visual Studio will transfer your code to the device (FEZ) and store it in a reserved region. This region of the chip is reserved for your managed application. Note that your application is only what you write, it doesn't include the NETMF libraries since they are already stored on the device via the firmware.

Lets say you write a program to read XML files. Your program will be simple. The complex work is done in FAT file system and XML libraries. Those libraries are already included in the framework (in the firmware).

Now, is it fast? Yes, it is fast depending on if you write your code right. It is a fact that managed code runs much slower than native code. Managed code runs checks at runtime, so for example when you access an array in C/C++, you can easily go over the array boundary undetected and overwrite some random memory. This is an extremely difficult bug to catch. Modern managed languages like C# check every time you access an array to see if you are within the boundaries or not. Such checks are great but they have their performance penalties.

The managed application is also interpreted, which also runs slower than native code. So if you're making a function that encrypts data, it will run too slow. Why? Because all the encryption code is interpreted. This is why NETMF includes a large set of libraries to accomplish many things including cryptography, for our example. When you try to encrypt the data, you will simply be passing your data onto the internal code which is not interpreted and it runs very fast.

Someone can comment and say, I can toggle a pin faster on a PIC/AVR/Arduino than I can on FEZ! This is correct, but what kind of project only toggles a pin? Make a decently sized project and then compare speed. Try our example from earlier, read an XML file from a USB thumb drive and parse it. Devices other than FEZ will probably not be capable of doing so and if they did it will be slower than FEZ. In short, use the built-in functions as much as you can and your project will run fast.

Is FEZ Real-time?

FEZ runs NETMF, which is not a real-time operating system. This functionality similar to most operating systems, such as Windows, MAC and Linux. When you command the operating system to do a task, you can't grantee when the OS is really going do it, within a reasonable time of course. For example, if you ask FEZ to make a pin high and FEZ received data from UART and the GarbageCollector was activated internally, then setting the pin high will still happen, just after a few milliseconds. In most cases you will not even notice that this took longer than expected. This doesn't mean FEZ is slow or unreliable, it means when you want something to happen you can't determine when will it happen exactly, especially if FEZ is doing multiple tasks.

While FEZ is not real-time, you can still get accurate timings if you know what you're doing. You have full control over what FEZ does, so when you're at a stage where timing is important, you can stop all threads and only hold on the critical event. FEZ will not do anything on its own, and so, it is somewhat real-time if it's free to do nothing but handle the timing.

There are methods to handle some time-critical tasks. For instance, if you are trying to decode an IR signal coming from a TV remote control then you can use the InterruptPort class which will give you events with pin states and a time stamp. Another option is using a very small micro that is programmed in assembly to do the real-time work and FEZ will only command the secondary chip. Such an example would be the VoiceBox shield. Generating a voice requires tight timing and this is done in a secondary chip. FEZ will only have to tell the chip what voice to make.

Finally, the term "real-time" can have many meanings for different designs. In some cases being 1us late causes problems. In others, being 1ms late is okay. If you are fine with being between 1ms to 10ms late then you can almost say FEZ is real-time, but if your application needs 1us accuracy then you need to plan your application like we mentioned earlier.

Is FEZ open source?

All FEZ boards are open source hardware. You are free to use the design files to make your own commercial boards.

The design files are included with FEZ downloads.

Who makes these products? How do they relate to Arduino?

The main FEZ boards and components are GHI Electronics, LLC products. Everything else is provided by Inex, DFRobot and others for your convenience. FEZ Domino and Mini are open source hardware but other boards may or may not be open source.

With the Arduino team's approval, FEZ Domino has a similar pin-out and layout to Arduino Duemilanove. This is not an Arduino product, it only has a similar pin-out, so you can use most of the available Arduino shields (we offer some on this website).

I want to design my own board. What should I do?

If you are making a FEZ mother-board like FEZ Cobra or FEZ Rhino then take the files provided and modify them anyway you like. Or easier, just use the files unmodified. If making a plug-in for the boards then follow what we have with one of the available plug-in components.

Can I build a commercial product with FEZ?

Absolutely! However, you may want to use FEZ boards for prototyping then just use USBizi Chipset or EMX Module in your products to save board space and cost.

Also, FEZ Cobra and FEZ Rhino come in a custom plastic enclosure making them ideal option for OEM. You only need to add your company logo sticker on the plastic enclosure to make your own product.

How can I lower the cost?

FEZ is ideal for prototyping and low volume production runs. For higher volume, you may want to start a new design that is based on the open-source-FEZ hardware and using the same powerful chipsets/modules. This will lower the cost and customize the circuit board specifically for your needs.
We also offer discounts on volumes over 100 units. Please contact GHI directly for further details.

What if I need more memory?

The core of FEZ Rhino, FEZ Domino and FEZ Mini is USBizi, which is a powerful chipset with limited memory. If your application requires more memory or resources then consider FEZ Cobra which is based on EMX Module.
Even further, concider ChipworkX Module.
The learning curve from one NETMF device to another is small or none, so its easy to start with FEZ Rhino then upgrade to more sophisticated device, like FEZ Cobra.

TinyCLR, NETMF, USBizi, FEZ... How do they relate?

Microsoft released an excellent technology called .NET Micro Framework or NETMF for short. This technology allows users to run C# managed applications on small embedded devices. This means, a PC programmer can now program a little device and even use Visual Studio without the need for any knowledge of electronics or embedded systems.

Now, the core of NETMF is a software called TinyCLR. TinyCLR is responsible of parsing/executing assemblies and managing system resources. GHI took NETMF and compressed it to the point it ran on a single chipset. This chipset is called USBizi. GHI also added a lot of features that are not available in NETMF, such as CAN, Analog In, Analog Out, PWM, USB host and many more.

Finally, FEZ boards are made directly for beginners and educational institutions. These boards use USBizi chipset at the core but what makes it easier is that everything is packaged and made with beginners in mind. For example, there are many sensors (which include a driver example) that are ready to plug right into FEZ. With connecting a few sensors and using the available drivers, a beginner can create all kinds of devices easily.

Even though the target is beginners, FEZ is also a great device for professionals that need to prototype new designs.

What are components, shields and extensions?

What do you have for academic institutions and instructors/professors?

FEZ is perfect for learning electronics, programming, .NET Micro Framework, embedded system and more! The hardware cost is very low and software is free. Also, FEZ is not a toy, it is based on the cutting-edge USBizi chipset that is used in many commercial projects around the world.
If you are interested in special educational pricing or in special kits that include components of your choice, please contact us directly.

Discounts are only available for 10 or more units and for educational institutions only, no student discount, sorry!

I created a component, shield, or extension. Can you offer it on this website?

Yes, if you are able to show the usefulness *and* quality of your device.
We are even open to a whole new FEZ family using USBizi or other GHI OEM products, like EMX or ChipworkX.

How much RAM and flash memory do I have for my application?

Smaller FEZes are based on the USBizi chipset. This means both have 512KB of flash memory and 98KB of RAM, with about 100KB flash and 50KB RAM left for user applications. These numbers don't mean much for NETMF users because the TinyCLR (firmware) and the libraries are already stored on USBizi. If you use threading then you still have about 100KB left, if you use XML then you still have about 100KB. What the application flash does is basically hold your application. So how much can you do with 100KB? If you're coming from the PC world then you'll think this is extremely small, but its not. Throughout the years we've had USBizi on the market being used by professionals, we've never had a customer complain about running out of flash memory. Yes, you can purposely fill the flash, but if you manage to write the code properly then 100KB is enough for any application where USBizi (FEZ) fits.

FEZ Cobra is based on EMX module and so it has much more RAM/FLASH than the other smaller FEZ devices, ideal for the built in graphics support.

For RAM, NETMF is a runtime managed system. This means it can be RAM hungry if the developer doesn't write code properly. Our free ebook talks about ways to "think small." 50KB of RAM is more than enough for any application if you plan your application properly.

An important note here is that most RAM usage on NETMF is dynamic (managed) which means you almost can't say that your application is using xx KB, because your program objects are continuously being allocated and freed depending on what the code is doing.

While most deep embedded applications fit well on USBizi (FEZ), you can always switch to larger devices like GHI's EMX and ChipworkX if necessary.

What assemblies (libraries) do I need to add to my project?

This is really easy to figure out from the documentation but you may find it difficult sometimes. Why not just add them all? As a beginner, your applications are still very small so you will have plenty of memory even if you add all assemblies, even if you are not using them.

These are the main assemblies that are most commonly used. Add them all for all of your projects for now. Once you know where everything belongs, you can start removing the ones you don't need.

GHIElectronics.NETMF.Hardware
GHIElectronics.NETMF.IO
GHIElectronics.NETMF.System
Microsoft.SPOT.Hardware
Microsoft.SPOT.Native
Microsoft.SPOT.Hardware.SeriaPort
Microsoft.SPOT.IO
mscorlib
System
System.IO

There are others like System.Xml that is only needed of you are parsing XML data.

Do not forget about FEZRhino_GHIElectronics.NETMF.FEZ or FEZCobra_GHIElectronics.NETMF.FEZ. These have the pin definitions.