Directories and Files in the QP-nano Distribution

The following annotated directory tree lists the most important directories and files provided in the standard QP-nano distribution. The explanation section immediately following the directory tree explains the structure in more detail.

 (1) qpn\                 - QP-nano root directory
       |
 (2)   +-qpn.chm          - "QP-nano Reference Manual" in CHM Help format
       |
 (3)   +-doxygen\         - QP documentation generated with Doxygen
       | +-html\          - "QP-nano Reference Manual" in HTML format
 (4)   | | +-index.html   - The HTML index page for the "QP-nano Reference Manual"
       | | +- . . .
       | +-Doxyfile       - Doxygen configuration file to generate the Manual
       | +- . . .
       |
 (5)   +-examples\        - QP-nano examples
 (6)   | +-80x86\         - Examples for the 80x86 processor
 (7)   | | +-tcpp101\     - Examples with the Turbo C++ 1.01 compiler
 (8)   | | | +-dpp\       - Dining Philosopher Problem (DPP) example (non-preemptive)
 (9)   | | | | +-dbg\     - Debug build
       | | | | | +-dpp.exe    - Debug executable
(10)   | | | | +-DPP.PRJ      - Turbo C++ project to build the application
(11)   | | | | +-qpn_port.h   - QP-nano port for this specific application  
       | | | | +- . . .
       | | | |
(12)   | | | +-dpp-qk\     - DPP example with the preemptive QK-nano kernel
       | | | | | +-dpp-qk.exe - Debug executable
(13)   | | | | +-DPP-QK.PRJ   - Turbo C++ project to build the Debug   version
       | | | | +-qpn_port.h   - QP-nano port for this specific application  
       | | | | +- . . .
       | | | |
       | | | +-game\       - "Fly 'n' Shoot" game example (non-preemptive kernel)
       | | | | +-dbg\      - Debug build
       | | | | | +-GAME.EXE   - Debug executable
       | | | | +-GAME.PRJ  - Turbo C++ project to build the Debug version
       | | | | +-game.h    - The application header file
       | | | | +-bsp.c     - BSP for the application
       | | | | +-main.c    - main() function
       | | | | +-qpn_port.h   - QP-nano port for this specific application  
       | | | | +- . . .
       | | | |
       | | | +-game-qk\    - "Fly 'n' Shoot" game with the preemptive QK-nano kernel
       | | | | +- . . .
       | | | |
       | | | +-pelican\    - PELICAN crossing example (non-preemptive kernel)
       | | | | +- . . .
       | | | |
       | | | +-pelican-qk\ - PELICAN crossing with the preemptive QK-nano kernel
       | | | | +- . . .
       | | | |
(14)   | | | +-comp\       - "Orthogonal Component" pattern (PSiCC2 Chapter 5)
       | | | +-defer\      - "Deferred Event" pattern (PSiCC2 Chapter 5)
       | | | +-history\    - "Transition to History" pattern (PSiCC2 Chapter 5)
       | | | +-hook\       - "Ultimate Hook" pattern (Chapter 5)
       | | | +-reminder\   - "Reminder" pattern (PSiCC2 Chapter 5)
       | | |
       | |
(15)   | +-cortex-m3\      - Examples for ARM Cortex-M3 processor
       | | +-iar\          - Examples with the IAR compiler
       | | | +-game-ev-lm3s811\       - "Fly 'n' Shoot" example for EV-LM3S811 board
       | | | +-game-qk-ev-lm3s811\    - "Fly 'n' Shoot" example with QK-nano
       | | | +-pelican-ev-lm3s811\    - PELICAN example for EV-LM3S811 board
       | | | +-pelican-qk-ev-lm3s811\ - PELICAN example with QK-nano
       | | | +-. . .       - Other examples for ARM Cortex-M3
       | |
(16)   | +-msp430\         - Examples for MSP430 processor
       | | +-iar\          - Examples with the IAR compiler
       | | | +-bomb-eZ430\       - Time Bomb example for eZ430 board
       | | | +-bomb-qk-eZ430\    - Time Bomb example with QK-nano
       | | | +-game-eZ430\       - "Fly 'n' Shoot" example for eZ430 board
       | | | +-game-qk-eZ430\    - "Fly 'n' Shoot" example with QK-nano
       | | | +-pelican-eZ430\    - PELICAN example for eZ430 board
       | | | +-pelican-qk-eZ430\ - PELICAN example with QK-nano
       | | | +-. . .      - Other examples for MSP430
       | |
       | +-. . .          - Examples for other CPUs and compilers
       |
(17)   +-include\         - QP-nano platform-independent header files
       | +-qassert.h      - QP-nano assertions
       | +-qepn.h         - QEP-nano platform-independent interface
       | +-qfn.h          - QF-nano platform-independent interface
       | +-qkn.h          - QK-nano platform-independent interface
       |
(18)   +-source\          - QP-nano platform-independent source code (*.c files)
       | +-qepn.c         - QEP-nano platform-independent source code
       | +-qfn.c          - QF-nano  platform-independent source code
       | +-qkn.c          - QK-nano  platform-independent source code
       | | +- . . .
       |

• (1) QP-nano resides in the separate directory branch, called henceforth QP-nano Root Directory. The essential element of the design is that the QP Root Directory can be "plugged into" any branch of a hierarchical file system and you can move the QP-nano Root Directory around, or even have multiple versions of the QP-nano Root Directories. The ability to relocate the QP-nano Root Directory means that only relative paths should be used in the Makefiles, build scripts, workspaces, or project files.

• (2) The file qpc.chm contains the "QP-nano Reference Manual" in CHM format.

• (3) The doxygen\ directory contains this "QP-nano Reference Manual" generated with the Doxygen utility.

• (4) The html\ subdirectory contains this HTML verions of the "QP-nano Reference Manual". In particular, the file index.html is the index page of the Manual.

• (5) The examples\ directory contains the application examples that are included in the standard QP-nano distribution. The structure of the examples\ is the most complicated because of the large number of choices available, such as CPU architectures, compilers, and two choices of kernels (non-preemptive and preemptive).

• (6) The CPU architecture is placed as the first level of nesting within the examples\ directory. Examples of CPU architectures are: 80x86, Cortex-M3, ARM, AVR, MSP430, M16C, etc. Please note that a separate directory is needed whenever the CPU architecture is significantly different. For example, even though the traditional ARM and the new ARM Cortex-M3 are related, the differences are significant enough to require a separate directory branch for ARM and Cortex-M3.

• (7) The second level of nesting, under the CPU architecture is the compiler used. For example, the 80x86 port can be compiled with the Turbo C++ 1.01 or perhaps with Visual C++ 1.52. Similarly, the port to Cortex-M3 with QK kernel can be compiled with the IAR, RealView, or GNU compilers.

• (8) Finally, the example application is located in its own directory. For instance, the dpp\ directory contains the "Dining Philosopher Problem" application example for this particular CPU/Compiler combination.

• (9) The dpp\dbg\ subdirectory contains the object files and the executable for the Debug configuration.

• (10) DPP.PRJ is the Turbo C++ 1.01 project file for building the application (Debug configuration).

• (11) THe qpn_port.h header file contains platform-specific adaptation (QP-nano) port for this application.

Note:

Every QP-nano application must provide its own specific qpn_port.h header file.

• (12) The dpp-qk directory contains the of the application with the QK-nano preemptive kernel

• (13) DPP-QK.PRJ is the Turbo C++ 1.01 project file for building the application with QK-nano (Debug configuration).

• (14) All five state designed patterns described in Chapter 5 of Practical UML Statecharts in C/C++, Second Edition (PSiCC2) are provided.

• (15) The directory cortex-m3\ contains QP examples for ARM Cortex-M3.

• (16) The directory msp430\ contains QP examples for Texas Instruments MSP430.

• (17) The directory include\ contains platform-independent header files for all QP-nano components. You need to point your C compiler to include files from this directory.

• (18) The directory source\ contains platform-independent source files for all QP-nano components.

Copyright © 2002-2008 Quantum Leaps, LLC. All Rights Reserved.

---