The DSC56800EX Quick Start is a software environment for the embedded applications development. It is based on the graphical configuration tool (GCT) and a unified application programming interface (API)-style of accessing the peripheral modules. The Quick_Start helps users to accelerate the application development, to become quickly familiar with the target device and to create real-time applications rapidly and efficiently while retaining complete control over each portion of the underlying hardware.
The DSC Quick Start toolset was specially designed for the hard-real-time applications written in C or mixed Assembler/C languages where deterministic behavior and transparent software structure are required. It provides a software infrastructure that allows development of efficient applications that are portable and reusable between devices within the architecture family or even between different architectures. The Quick_Start tool complements the other development and initialization tools for Freescale processors like Processor ExpertTM TM or RAppID.
The Quick_Start tool version 2.6 is now available for the new 56800EX family of Digital Signal Controllers. It provides the out of box support for 56F82xxx and 56F84xxx devices and evaluation boards. The version 2.5 is still available for download and supports the 56800 and 56800E families of DSC (56F83xx, 56F82xx and 56F80xx).
New in Version 2.6
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:
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.
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);
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.