Features

Core-system Infrastructure

The core-system infrastructure creates the fundamental environment for the processor operation and enables further integration with other components, such as low-level drivers. The core components are:

• Common C types and macros. All Quick_Start declarations use the same set of types. It is up to the user either to adopt these types, use her own or even use the native C types for an application development.
• Architecture-specific register maps for all peripheral modules implemented as C structures. A single master structure then describes all peripheral registers of the target device. Thanks to a powerful expression analyzer built in the CodeWarrior Assembler, the C-like structure mnemonics may be used in the inline assembler code, too.
• Project templates for creating a new project in the CodeWarrior framework. Such templates are referred to as the "project stationery" and contain complete projects ready to be used on the selected devices and development boards. Every project in the Quick_Start contains several "targets", bringing to the developer a choice of pre-defined compiler and linker configurations covering RAM-based debugging, standalone operation from flash and core simulation options.
• Debugger and linker configuration files for each device. As mentioned above the debugger and linker files are specific for each device and each target in the Quick_Start projects.
• The startup code and interrupt vector tableare both graphically configurable from within the GCT. These two components are also part of the project stationery and are always copied into each new project created with Quick_Start.

Graphical Configuration Tool

The GCT is an easy-to-use graphical interface in which the user defines a startup configuration for all peripheral modules, including the processor core and interrupt vector table. This tool simplifies the configuration of on-chip peripheral modules and the device itself. It also guides the user by supplying a lot of useful information and hints, such as providing a list of available settings and modes for register bits or bit-fields. The output of the tool is a set of constants which may be used to initialize peripheral registers. All constants are written into a single ANSI C header file, which is included directly by the application source files. This file is also parsed and used as a native input to the GCT, which enables manual editing of the file, as well as a cut-and-paste method of importing the configuration between different projects. The constants generated in the header file may be used by the user in any way. The most convenient is to use the Quick_Start low-level driver initialization calls, which apply the module configuration by writing the values directly into the peripheral registers. 

The GCT is implemented as a desktop application for the Windows® Operating Systems. The application graphical user interface (GUI) resembles standard document content browsers, with navigation bookmarks for each peripheral module, back and forward buttons, cross page hyperlinks and so on. Each peripheral module has its own control page with detailed graphical settings for each bit or bit-field in peripheral registers. Potential configuration conflicts between individual modules are monitored and displayed to the user. To understand and resolve all possible conflicts, each configuration window is linked with the appropriate page in the device user manual. The tool may also display direct register values, making it more convenient for the user to look up an appropriate section in the documentation.

The GCT can work as a stand-alone tool, however, its integration into the CodeWarrior environment increases the tool efficiency. When integrated, the GCT can be invoked simply by pressing a hot key in the CodeWarrior IDE. The GCT then opens and automatically loads the active project's header file.

Low-level Peripheral Drivers

The peripheral drivers isolate the hardware-specific functionality into a set of driver commands with a well-defined API. The API implements a thin abstraction layer between the software and the hardware levels. Such an isolation enables a sufficient level of portability or architectural and hardware independence for the application code. It also allows separating the C application from hardware particularities that are often tough to code in C, such as access to registers with read or write side effects or interrupt flag clearing mechanisms.

The Quick_Start low-level drivers give full control and access to all processor resources. Registers are not accessed directly, although this is still possible. The low-level drivers unify accesses to peripheral memory space using the ioctl macros or calls, which are, in most cases, compiled into an optimal assembly code. The general form of the ioctl driver command is:

ioctl(peripheral_module_id, command, command_parameter);

where

• the peripheral_module_id parameter represents the base address of the peripheral module. Predefined symbolic constants, such as SCI_0, ADC_A, PWM etc., are used as such module identifiers.
• The command specifies the action that will be performed on the peripheral module.
• The command_parameter then specifies the data required to execute the command, or is NULL when no parameter is required.

A typical example is shown in the figure below.

There are also more advanced commands in the Quick_Start tool. Such commands incorporate some higher functionality rather than a simple access to the peripheral registers. An example can be commands that perform mathematical calculations for data scaling to fit the results into the desired data range, such as recounting of the PWM duty cycle (pulse width) as a percentage of the actual value to be written to the dedicated PWM register.

As already mentioned above, all peripheral drivers always contain one command which performs a static initialization of the module according to the constants defined in the GCT-edited header file (the file is named appconfig.h). Examples of such initialization commands may be SCI_INIT, PWM_INIT, ADC_INIT and so forth.

FreeMASTER Software Drivers

The FreeMASTER is a graphical visualization and control tool which is freely available to be used and redistributed with applications based on the Freescale microprocessor units. The FreeMASTER communication drivers are available for a wide range of Freescale processors as a standalone software pack available for download. For user convenience, the Quick_Start tool includes the latest released version of the FreeMASTER communication drivers so there is no need to download and install them separately. Also there are two FreeMASTER example applications for each supported development board in the DSP5600E_Quick_Start. Please see more details about the FreeMASTER tool and the FreeMASTER serial communication driver on the FreeMASTER homepage.

Example Applications and User Documentation

Another important part of the Quick_Start tool is a set of sample applications for all supported development boards that are available from Freescale. Although very small and simple, the sample applications show the basic principles of the GCT and demonstrate correct usage of the low-level drivers. The user documentation is designed to be very comprehensive, providing all the information required for successful application development. It starts with a list of guidelines for installing the GCT and low level drivers and a description of the core system infrastructure. This isfollowed by explanations for data types, system routines and special macros. The next sections are dedicated to the interrupt processing, on-chip drivers and FreeMASTER interface. All sections include software examples that illustrate discussed topics in C or assembler language.

Supported Device Families

• Digital Signal Processors & Controllers