![[Previous]](prev.gif) |
![[Contents]](contents.gif) |
![[Index]](keyword_index.gif) |
![[Next]](next.gif) |
|
|
|
|
 |
This version of this document is no longer maintained. For the latest documentation, see http://www.qnx.com/developers/docs. |
As a complete package designed for embedded systems developers, the QNX Momentics development suite gives you everything you need at every stage of your product-development cycle:
Full source code for numerous startup programs, IPLs, device drivers, etc. is available from our website.
There are two versions of QNX Momentics: the Standard Edition (SE) and the Professional Edition (PE). PE includes everything that's in SE, as well as our Integrated Development Environment. For Windows hosts, PE also includes the Rational ROSE Adaptation Layer as well as Phindows ("Photon in Windows").
Here are the main parts of your QNX Momentics suite:
If you've installed the Standard or Professional Edition, you can download these components from our website after logging into your myQNX account:
Note that the QNX Momentics development suite includes the DDK documentation.
These components are available separately:
The TDKs currently include:
For more information about these components, contact your sales representative.
Assuming you plan to develop a Neutrino-based embedded system of some kind (e.g. a vehicle telematics system, a router, a medical imaging device), you can start developing your application, even before you have your target hardware.
And if you haven't yet decided on the CPU family for your target (e.g. PowerPC, XScale), you can still begin developing your application. As a rule, with QNX Momentics you write your application code once, then compile it however many times you need for whatever supported targets you're using. As you'll see if you plan to use the IDE, you can build the very same project for any of our supported processors with just a couple of mouse clicks.
If you're developing on a self-hosted Neutrino system, you can run your application directly on your development machine.
Consider the following scenarios:
If your final target hardware will be a PC in some shape or form (e.g. a PC/104 SBC module), you can simply connect your host to any spare PC and use that as your temporary target. You should expect to make very few changes (if any) in your application when the time comes to move to your final target.
And if you don't happen to have a spare PC, you could use a virtual machine -- products such as Workstation by VMware (http://www.vmware.com) can emulate a separate, complete hardware environment right on your desktop. You can get a free, time-limited evaluation of this product from the vendor.
Once you've set up a virtual machine (VM) on your host, you can then use it as your target -- you can run, test, and debug your Neutrino applications on the VM as if it were an actual machine connected to your host.
 |
Virtual machines probably don't support hard realtime. |
In this case, the target computer (e.g. an SC400) isn't a PC. It doesn't have a BIOS, so it won't boot and load Neutrino in the same way as a PC. In order to run Neutrino on such a target, you need an appropriate BSP for your particular hardware, including an IPL that could set up the processor and load Neutrino properly.
|
We're continually adding new BSPs to our extensive selection; for a list, see the Products area of our website, http://www.qnx.com. If you don't see a BSP for your target hardware, contact us. |
You can develop your application without target hardware, because much of your code will be hardware-independent. For device drivers and other hardware-specific areas of your system, you may be able to use a virtual platform tool that accurately emulates your specific embedded system hardware.
For instance, Virtio (http://www.virtio.com) makes virtual platforms that emulate various processors and peripherals, right down to the CPU's instruction set. You can download a free time-limited eval copy from the vendor's website.
Whatever your target hardware, you can still go a long way down your development path using QNX Momentics right now. Develop all your application-level components first, leaving device drivers and other hardware-specific details until you have your target hardware.
As mentioned earlier, you might want to consider Virtio if you need a functionally accurate virtual prototype of your embedded platform before you have the actual hardware itself.
Whatever the specific CPU family, your application code will, in most cases, run unchanged when you go to your final target. But you may need to be aware of a few platform-related issues (e.g. endian differences, CPU speeds, I/O addressing, alignment of data structures, synchronization on SMP vs uniprocessor systems, etc.).
Fortunately, QNX Momentics includes several header files and convenience functions that will help you anticipate and easily handle such problems.
|
For more information on these and other platform-related issues, see Freedom from Hardware and Platform Dependencies in the Neutrino Programmer's Guide. |
Here are some general questions about licensing. For more information, visit the Legal area of http://www.qnx.com, where you'll find details on our licensing model, types of licenses, etc., or email licensing@qnx.com.
If you have a source license, you'll also find your agreement on our website.
If you're migrating from QNX 4 to Neutrino, you should download the migration kit from the Download Center area in our website, http://www.qnx.com, after logging into your myQNX account. This free kit includes:
|
|
|
|