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)   | | +-watcom\      - Examples with the Open Watcom compiler
 (8)   | | | +-dpp\       - Dining Philosopher Problem (DPP) example (non-preemptive)
 (9)   | | | | +-dbg\     - Debug build
       | | | | | +-dpp.exe    - Debug executable
(10)   | | | | +-make.bat     - batch script 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)   | | | | +-make.bat     - batch script 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
       | | | | +-make.bat  - batch script 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)   | +-arm-cortex\     - Examples for ARM Cortex 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
       | | |
       | | +-gnu\          - Examples with the GNU compiler (Code Sourcery G++)
       | | | +-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
       | |
(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, ARM, ARM Cortex, 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 are related, the differences are significant enough to require a separate directory branch for ARM and ARM Cortex.

(7) The second level of nesting, under the CPU architecture is the compiler used. For example, the 80x86 port can be compiled with the Open Watcom or perhaps with Borland C++. Similarly, the port to ARM Cortex 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) make.bat is the batch script for building the application.

(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) make.bat is the batch script for building the application with QK-nano.

(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 arm-cortex\ contains QP examples for ARM Cortex.

(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.