What is FEZ?

FEZ is GHI's NETMF product line that is targets for quick prototyping and for hobbyists. The base of FEZ is one of the GHI's professional offers (EMX, USBizi)found on GHI's main website.

With the complete built-in feature, you are surly to get about everything you need, software and hardware, in a simple package that can be programmed in .NET C# and using Visual Studio express, the best free IDE.

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. Plus hundreds of drivers found at www.fezzer.com

Where do I get more help?

We have it all, a mouse click away!

• Free "Beginner Guide" ebook. The book is also on the wiki so the community can enhance and translate. See the wiki for current book translations.
• The wiki is full of community projects and be sure to checkout the videos.
• Complete website for open-source code sharing called Fezzer.
• Last but not least, our forum has a great community monitored by our dedicated GHI support team. Post a question and give it a try!

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.

What device should I select? Is USBizi powerful enough?

NETMF devices can be categorized into two types, those with external memory and those without. For example, FEZ Panda (based on USBizi chipset) has 148KB of FLASH to hold the user's software and 62KB of RAM for application data. Compare that with FEZ Cobra (based on EMX module), 3000KB of FLASH and 12000KB of RAM and you can see a major difference in memory size. Does this mean FEZ Panda won't run applications well?

Rest assured, FEZ Panda can do a lot more than developers think. You just have to plan your application properly. The following video shows a home automation demo running on FEZ Panda. It uses Ethernet with HTTP webserver running right on FEZ Panda with graphical color touch display.



If FEZ Panda can handle such tasks, why should I use EMX with more memory?
Most features are identical on FEZ Panda and FEZ Cobra, Threading, Memory Management, USB Client services, USB Host, serial ports, SPI, CAN, I2C, One Wire, etc. These are all identical on every device. The differences come mainly in networking and graphics support.

Graphics use a lot of ram quickly. A simple 480x272 image will use about 300KB of RAM! Also, if you need to decode JPEG images then you need about 100KB FLASH for the JPEG decoder. That's why native graphics are only supported on larger devices with external memory. On smaller devices, you can still run color displays but there is no JPEG decoding and you can't use the "Bitmap" class. The images will be as simple as byte arrays that are passed to the display. If your application is a smart thermostat then USBizi's limited graphics is enough, but if your device is used in Point of Sale (POS) then you will need a device with external memory, like EMX.

Networking is another area where memory is needed. The TCP/IP stack needs a lot of FLASH, add HTTP, DNS and DHCP and you will be running out of memory fast. GHI actually ran some tests and realized that adding TCP/IP stack onto a single chip with no external memory, leaves the device with little resources, not even enough to handle a simple application. To solve this, GHI used W5100 TCP/IP chipset to handle the networking overhead. The built-in native drivers developed by GHI expose the networking interface as a standard ".NET socket" so it's no different than using a larger device with a built-in TCP/IP stack. The limitation is four simultaneous connections but a developer can close one connection to establish another one. Comparing networking to larger devices, you see SSL support for secure connections, at least 128 simultaneous connections, PPP, and WiFi. Plus, there is enough memory in the system to handle networking traffic.

If you are still not sure what device you need then please contact GHI with details on your project and we will gladly direct you to the optimal solution at the lowest price.

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.

Let's 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 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 many components are made by GHI Electronics, LLC. Some components maybe provided by Inex, DFRobot,Sparkfun and others for your convenience.

With the Arduino team's approval, some FEZ devices have a similar pin-out and layout to Arduino Duemilanove. These boards are not an Arduino product, they only have 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 planning to make a FEZ mother-board like the FEZ Cobra or FEZ Rhino then you may take the files provided and modify them any way you like. You may also use the files unmodified if you wish. If you are making a plug-in for the existing boards, then use of the available plug-in components as a guide/template

Can I build a commercial product with FEZ?

Absolutely! However, you may want to use FEZ boards for prototyping. This way you can use a module like 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. By using the same powerful chipsets/modules you may 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 the 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 to none, so it's easy to start with a FEZ Rhino then upgrade to a 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 an embedded device and use Microsoft Visual Studio without the need for any knowledge of electronics or embedded systems.

The core of NETMF is a piece of software called TinyCLR. TinyCLR is responsible for parsing/executing assemblies and managing system resources. GHI have taken NETMF and re-written it to run on a single microchip called USBizi. GHI have also added a lot of features to NETMF such as CAN, Analog Input, Analog Output, PWM, USB host controller and many more.

FEZ boards use the USBizi chipset and are designed with beginners, hobbyists and educational institutions in mind. FEZ boards are intended to be extremely easy to use and learn. For example, there are many sensors (which include a driver/code example) which are ready to plug right into the FEZ boards. By connecting a few sensors and using the available drivers a beginner can create all kinds of devices very easily. Although the FEZ boards target hobbyists, FEZ allows rapid prototyping of new designs for professionals.

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 systems, and more! FEZ hardware very cost effective and the software is free. FEZ is is based on cutting-edge technologies such as the USBizi chipset which is used in many commercial projects around the world.
If you are interested in educational pricing or in custom kits that include your choice of components, please contact us directly.

Discounts are only available for volume purchases of 10 or more units by educational institutions. We do not offer discounts for students.

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.

NETMF is open source so why do I need FEZ or any other GHI product?

On our downloads page, you will find the Porting Kit (PK) download link for NETMF. This is a Microsoft product and it is open source. When using a GHI NETMF product, you are not paying for NETMF but for the free and unlimited features, support, maintenance, robustness and time-to-market. Let's cover these in detail.

Features - GHI NETMF products include many exclusive features, such as USB Host, USB Device, one-wire, CAN, PPP, WiFi; too many to list here. All these are included at no additional cost. GHI continues to adds exclusive features via updates free of charge!

Support - Our world-class support is free. The same engineers that invented these devices are monitoring the forums, emails and phone to provide superior support. We're here to assist you every step of the way until your product is on the market as soon as possible. We would love for you to visit our forum and ask other customers how satisfied they are with GHI support.

Maintenance - Every few months, Microsoft releases a new NETMF version. GHI works very closely with Microsoft on any new possible issues and does all the work required to update all GHI's NETMF devices. For GHI customers, this is a five minute FREE firmware update and GHI takes care of the rest.

Robustness - There are thousands of GHI's NETMF devices used around the world in most markets. This vast usage guarantees quality and stability of GHI Electronics products. You can use any of the GHI Electronics products with ease of mind.

Time-to-Market - Using GHI Electronics products (FEZ or others) will speed up development. Your design is almost done as soon as you add one of the GHI NETMF products. We have seen customers that create full products in a week! You can for example, take a FEZ Rhino starter kit, write a little code over a few days, add your company's logo-sticker on top and you have your own product. You will probably spend most of your time designing/ordering the logo-sticker than you would spend on the hardware design!

Everything discussed above is related to the internal C++ HAL/PAL drivers, and not the high level managed drivers nor NETMF core. The NETMF core is completely open source (Porting Kit) and so are all our managed (C#) drivers for components. Even the hardware design files for all FEZ devices are open source. Not only that, the USBizi chipset (the core of FEZ) is selling at near cost (for non-commercial use) so technically, you are getting all the features above for free!

What features GHI adds on top of NETMF and what is included from NETMF?

GHI devices include nearly all the standard NETMF features in addition to our exclusive commercial-quality libraries.

NETMF standard feature:

• UART (serial COM port)
• SPI
• I2C
• Digital input and outputs
• TCP/IP with SSL
• Graphics

Note: Smaller devices, like USBizi (base of FEZ Panda for example) doesn't have enough resources to run the NETMF native TCP/IP stack. Adding native TCP/IP will leave such a small device with very little unusable memory. No need to worry though, GHI added its own scaled down implementation that requires very little resources and runs TCP/IP on these small devices using Wiznet W5100 Ethernet controller.

Note: Native NETMF graphics needs megabytes of memory. As an alternative, GHI provides many displays with scaled down graphics libraries supporting multiple font sizes and drawing shapes.

GHI's exclusive commercial-grade features (not usually found on any other NETMF devices):

• Standard .NET file system support on 4-bit SD cards (not SPI) supporting SD cards of any size (no 2GB limit).
• Full customization and control of USB Client.
• Allowing virtual serial port on USB client (CDC), with GHI supplied windows drivers.
• Supporting the USB client port to be used for debugging while also enabling a virtual serial port.
• Supporting the USB client interface to work like a card reader (MSC), hooking into the SD cards. The GHI NETMF device basically becomes a USB SD card reader
• Debugging/deploying programs using USB or serial interfaces. Switching between the interfaces is done by a simple pin, the same firmware does it all.
• USB Host allows you to connect almost any USB device such as USB mouse, USB keyboard, USB joystick, USB thumb drive and more.
• Standard .NET TCP/IP socket support on resource-limited devices (USBizi), with TCP (client and server), UDP and HTTP. See note above.
• PPP stack allows networking through cell phone modems.
• WiFi
• Built-in real-time-clock (RTC) to keep track of time even if the device is powered off, with drivers to use the RTC and the built-in alarm.
• OutputCompare that allows generating waveforms. Generate software-PWM, tones, UART or even TV remote waveforms easily. Runs on any digital IO and is not system blocking (runs in background on interrupts).
• OneWire support with complete library, including CRC calculation.
• PWM with nanosecond accuracy.
• Analog inputs with automated value scaling.
• Analog out out which can also playback WAV files.
• CAN (Controller Area Network).
• Parallel port support (useful for parallel display on smaller systems).
• Watchdog
• Special libraries to aid in programming. For example, converting floats to byte arrays.
• Extended math library with double accuracy, implemented natively for superior performance.
• Native implementation of 16-bit and 32-bit CRC.
• Register access for control over the core processor and to build native drivers.