Figure 2-11 Windows Embedded CE device emulator
Chapter Review
The Windows Embedded CE build process includes several phases and relies on a variety of build and run-time image configuration files to compile the source code and create the run-time image. It includes a compile phase to generate .exe files, static libraries, DLLs, and binary resource (.res) files for the BSP and subprojects; a Sysgen phase to filter and copy source code based on SYSGEN variables from the Public folder for catalog items selected in the OS design, and create a set of run-time image configuration files; a Release Copy phase to copy the files from the BSP and subprojects required to build the run-time image into the release directory; and finally a Make Run-time Image phase to create the run-time image from the content in the release directory according to the setting specified in .bib, .reg, .db, and .dat files.
You can examine the build process if you analyze the information that Platform Builder generates and tracks in Build.log, Build.wrn, and Build.err files. The Build.log file contains detailed information about every build command issued in each build phase. Build.wrn and Build.err contain the same information, but filtered for warnings and errors encountered during the build process. You do not need to open these text files directly in Notepad. It is more convenient to work with build status information and error messages in Visual Studio. The Output window and the Error List window provide convenient access.
Build errors can occur for a variety of reasons. The most common causes are compiler and linker errors. For example, running build commands in an incorrectly initialized build environment will lead to linker errors when environment variables that identify library directories in the Sources file point to invalid locations. Other important build configuration files, such as Dirs files and Makefile.def, can also rely on SYSGEN variables and environment variables in conditional statements and in directory paths.
Having successfully generated a run-time image, you can deploy Windows Embedded CE on a target device. This requires you to configure a device connection based on the Core Connectivity infrastructure. The final deployment step is simply to click the Attach Device command that you can find on the Target menu in Visual Studio with Platform Builder for Windows Embedded CE 6.0 R2.
It is important that you are familiar with the following configuration files, which control the Windows Embedded CE build process:
■ Binary image builder (.bib) files Configure the memory layout and determine the files included in the run-time image.
■ Registry (.reg) files Initialize the system registry on the target device.
■ Database (.db) files Set up the default object store.
■ File system (.dat) files Initialize the RAM file system layout at start time.
■ Dirs files Determine which directories to include in the build process.
■ Sources files Define preprocessing directives, commands, macros, and other processing instructions for the compiler and linker. Take the place of Makefile files in the Visual Studio with Platform Builder IDE.
■ Makefile files Reference the default Makefile.def file and should not be edited.
Key Terms
Do you know what these key terms mean? You can check your answers by looking up the terms in the glossary at the end of the book.
■ Sysgen
■ Buildrel
■ Flat release directory
■ Connectivity options
■ KITL
Suggested Practice
To help you successfully master the exam objectives presented in this chapter, complete the following tasks:
Start the Build Process from the Command Line
To increase your understanding of the Windows Embedded CE build processes, perform the following steps:
■ Sysgen process Run sysgen -q from the command line after setting an environment variable in a catalog item.
■ Build process Open a Command Prompt window, change into the current BSP folder (%_TARGETPLATROOT%) and run build-c with and without setting the WINCEREL environment variable to 1 (set WINCEREL=1). Check the content of the %_FLATRELEASEDIR% folder before and after the build.
Deploy Run-Time Images
Deploy a Windows Embedded CE run-time image to a Device Emulator by using different download, transport, and debugging settings for the target device in Platform Builder.
Clone a Public Catalog Component Manually
Clone a component from the %_WINCEROOT%\Public folder by copying the source files to a BSP, as explained in Chapter 1, "Customizing the Operating System Design." Next, run sysgen_capture to create a Sources file that defines the component dependencies. Modify the new Sources file to build the component as part of your BSP. For detailed step-by-step information to accomplish this advanced development task, read the section "Using the Sysgen Capture Tool" in the Platform Builder for Microsoft Windows Embedded CE product documentation available on the Microsoft MSDN® website at http://msdn2.microsoft.com/en-us/library/aa924385.aspx.
Chapter 3
Performing System Programming
System performance is critical for user productivity. It directly influences the user's perception of a device. In fact, it is not uncommon for users to judge the usefulness of a device based on the performance of the system and the look and feel of the user interface. By providing too complex of an interface, you can confuse users and open your device to potential security risks or unexpected user manipulations. By using the incorrect APIs, or incorrect applications architecture in a multithreaded environment, you may significantly impact performance. Performance optimization and system customization are real challenges for firmware providers. This chapter discusses the tools and highlights best practices to achieve optimal system response times on target devices.
Exam objectives in this chapter:
■ Monitoring and optimizing system performance
■ Implementing system applications
■ Programming with threads and thread synchronization objects
■ Implementing exception handling in drivers and applications
■ Supporting power management at the system level
To complete the lessons in this chapter, you must have the following:
■ A thorough understanding of real-time systems design concepts, such as scheduler functionality in an operating system, interrupts, and timers.
■ Basic knowledge of multithreaded programming, including synchronization objects.
■ A development computer with Microsoft® Visual Studio® 2005 Service Pack 1 and Platform Builder for Microsoft Windows® Embedded CE 6.0 installed.
Lesson 1: Monitoring and Optimizing System Performance
Performance monitoring and optimization are important tasks in the development of small-footprint devices. The need for optimized system performance remains critical because of an ever-growing number of increasingly complex applications and the requirement for intuitive and therefore resource-intensive user interfaces. Performance optimization requires firmware architects and software developers to constrain resource consumption within their system components and applications so that other components and applications can use the available resources. Whether developing device drivers or user applications, optimized processing algorithms can help to save processor cycles, and efficient data structures can preserve memory. Tools exist at all system levels to identify performance issues within and between drivers, applications, and other components.