Showing preview only (9,477K chars total). Download the full file or copy to clipboard to get everything.
Repository: QuantumLeaps/qpn
Branch: master
Commit: 779ef14dc1c7
Files: 828
Total size: 8.9 MB
Directory structure:
gitextract_iaujvinz/
├── .gitignore
├── .gitmodules
├── GPLv3.txt
├── LICENSE.txt
├── README.md
├── doxygen/
│ ├── Doxyfile
│ ├── Doxyfile-CHM
│ ├── api.dox
│ ├── exa.dox
│ ├── exa_apps.dox
│ ├── exa_native.dox
│ ├── exa_os.dox
│ ├── gs.dox
│ ├── history.dox
│ ├── img/
│ │ └── img.htm
│ ├── lint.dox
│ ├── macros.h
│ ├── main.dox
│ ├── make.bat
│ ├── modules.dox
│ ├── ports.dox
│ ├── ports_arm-cm.dox
│ ├── ports_native.dox
│ ├── ports_os.dox
│ ├── preview.js
│ ├── rsm.bat
│ ├── rsm_qpn.cfg
│ ├── snippets/
│ │ ├── qepn_qhist.c
│ │ ├── qepn_qhsm.c
│ │ ├── qepn_qhsm_ctor.c
│ │ ├── qepn_qhsm_use.c
│ │ ├── qepn_qinit.c
│ │ ├── qepn_qtran.c
│ │ ├── qfn_armx.c
│ │ ├── qfn_main.c
│ │ ├── qfn_post.c
│ │ ├── qfn_postx.c
│ │ ├── qfn_qactive.c
│ │ ├── qfn_tickx.c
│ │ ├── qkn_lock.c
│ │ └── qkn_oncontextsw.c
│ └── struct.dox
├── examples/
│ ├── README.url
│ ├── arm-cm/
│ │ ├── README.url
│ │ ├── blinky_efm32-slstk3401a/
│ │ │ ├── README.txt
│ │ │ ├── README.url
│ │ │ ├── blinky.c
│ │ │ ├── blinky.h
│ │ │ ├── bsp.h
│ │ │ ├── main.c
│ │ │ ├── qk/
│ │ │ │ ├── armclang/
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── blinky-qk.uvoptx
│ │ │ │ │ └── blinky-qk.uvprojx
│ │ │ │ ├── bsp.c
│ │ │ │ ├── gnu/
│ │ │ │ │ ├── Makefile
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── blinky-qk.ld
│ │ │ │ │ └── flash.bat
│ │ │ │ └── iar/
│ │ │ │ ├── README.txt
│ │ │ │ ├── blinky-qk.ewd
│ │ │ │ ├── blinky-qk.ewp
│ │ │ │ ├── blinky-qk.eww
│ │ │ │ └── blinky-qk.icf
│ │ │ ├── qpn_conf.h
│ │ │ └── qv/
│ │ │ ├── armclang/
│ │ │ │ ├── README.txt
│ │ │ │ ├── blinky-qv.uvoptx
│ │ │ │ └── blinky-qv.uvprojx
│ │ │ ├── bsp.c
│ │ │ ├── gnu/
│ │ │ │ ├── Makefile
│ │ │ │ ├── README.txt
│ │ │ │ ├── blinky-qv.ld
│ │ │ │ └── flash.bat
│ │ │ └── iar/
│ │ │ ├── README.txt
│ │ │ ├── blinky-qv.ewd
│ │ │ ├── blinky-qv.ewp
│ │ │ ├── blinky-qv.eww
│ │ │ └── blinky-qv.icf
│ │ ├── blinky_ek-tm4c123gxl/
│ │ │ ├── README.txt
│ │ │ ├── README.url
│ │ │ ├── blinky.c
│ │ │ ├── blinky.h
│ │ │ ├── bsp.h
│ │ │ ├── main.c
│ │ │ ├── qk/
│ │ │ │ ├── arm/
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── blinky-qk.uvoptx
│ │ │ │ │ └── blinky-qk.uvprojx
│ │ │ │ ├── armclang/
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── blinky-qk.uvoptx
│ │ │ │ │ └── blinky-qk.uvprojx
│ │ │ │ ├── bsp.c
│ │ │ │ ├── gnu/
│ │ │ │ │ ├── .ccsproject
│ │ │ │ │ ├── .cproject
│ │ │ │ │ ├── .project
│ │ │ │ │ ├── Makefile
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── blinky-qk.ld
│ │ │ │ │ └── flash.bat
│ │ │ │ └── iar/
│ │ │ │ ├── README.txt
│ │ │ │ ├── blinky-qk.ewd
│ │ │ │ ├── blinky-qk.ewp
│ │ │ │ ├── blinky-qk.eww
│ │ │ │ └── blinky-qk.icf
│ │ │ ├── qpn_conf.h
│ │ │ └── qv/
│ │ │ ├── arm/
│ │ │ │ ├── README.txt
│ │ │ │ ├── blinky-qv.uvoptx
│ │ │ │ └── blinky-qv.uvprojx
│ │ │ ├── armclang/
│ │ │ │ ├── README.txt
│ │ │ │ ├── blinky-qv.uvoptx
│ │ │ │ └── blinky-qv.uvprojx
│ │ │ ├── bsp.c
│ │ │ ├── gnu/
│ │ │ │ ├── .ccsproject
│ │ │ │ ├── .cproject
│ │ │ │ ├── .project
│ │ │ │ ├── Makefile
│ │ │ │ ├── README.txt
│ │ │ │ ├── blinky-qv.ld
│ │ │ │ └── flash.bat
│ │ │ └── iar/
│ │ │ ├── README.txt
│ │ │ ├── blinky-qv.ewd
│ │ │ ├── blinky-qv.ewp
│ │ │ ├── blinky-qv.eww
│ │ │ └── blinky-qv.icf
│ │ ├── dpp_efm32-slstk3401a/
│ │ │ ├── README.txt
│ │ │ ├── README.url
│ │ │ ├── bsp.h
│ │ │ ├── dpp.h
│ │ │ ├── dpp.qm
│ │ │ ├── main.c
│ │ │ ├── philo.c
│ │ │ ├── qk/
│ │ │ │ ├── armclang/
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── dpp-qk.uvoptx
│ │ │ │ │ └── dpp-qk.uvprojx
│ │ │ │ ├── bsp.c
│ │ │ │ ├── gnu/
│ │ │ │ │ ├── Makefile
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── dpp-qk.ld
│ │ │ │ │ └── flash.bat
│ │ │ │ └── iar/
│ │ │ │ ├── README.txt
│ │ │ │ ├── dpp-qk.ewd
│ │ │ │ ├── dpp-qk.ewp
│ │ │ │ ├── dpp-qk.eww
│ │ │ │ └── dpp-qk.icf
│ │ │ ├── qpn_conf.h
│ │ │ ├── qv/
│ │ │ │ ├── armclang/
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── dpp-qv.uvoptx
│ │ │ │ │ └── dpp-qv.uvprojx
│ │ │ │ ├── bsp.c
│ │ │ │ ├── gnu/
│ │ │ │ │ ├── Makefile
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── dpp-qv.ld
│ │ │ │ │ └── flash.bat
│ │ │ │ └── iar/
│ │ │ │ ├── README.txt
│ │ │ │ ├── dpp-qv.ewd
│ │ │ │ ├── dpp-qv.ewp
│ │ │ │ ├── dpp-qv.eww
│ │ │ │ └── dpp-qv.icf
│ │ │ ├── table.c
│ │ │ └── win32-gui/
│ │ │ ├── Resource.rc
│ │ │ ├── bsp.c
│ │ │ ├── dpp-gui.sln
│ │ │ ├── dpp-gui.vcxproj
│ │ │ ├── dpp-gui.vcxproj.filters
│ │ │ └── resource.h
│ │ ├── dpp_ek-tm4c123gxl/
│ │ │ ├── README.txt
│ │ │ ├── README.url
│ │ │ ├── bsp.h
│ │ │ ├── dpp.h
│ │ │ ├── dpp.qm
│ │ │ ├── lint-plus/
│ │ │ │ ├── README.txt
│ │ │ │ ├── lin.bat
│ │ │ │ └── options.lnt
│ │ │ ├── main.c
│ │ │ ├── philo.c
│ │ │ ├── qk/
│ │ │ │ ├── arm/
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── dpp-qk.uvoptx
│ │ │ │ │ └── dpp-qk.uvprojx
│ │ │ │ ├── armclang/
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── dpp-qk.uvoptx
│ │ │ │ │ └── dpp-qk.uvprojx
│ │ │ │ ├── bsp.c
│ │ │ │ ├── gnu/
│ │ │ │ │ ├── .ccsproject
│ │ │ │ │ ├── .cproject
│ │ │ │ │ ├── .project
│ │ │ │ │ ├── Makefile
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── dpp-qk.ld
│ │ │ │ │ └── flash.bat
│ │ │ │ └── iar/
│ │ │ │ ├── README.txt
│ │ │ │ ├── dpp-qk.ewd
│ │ │ │ ├── dpp-qk.ewp
│ │ │ │ ├── dpp-qk.eww
│ │ │ │ └── dpp-qk.icf
│ │ │ ├── qpn_conf.h
│ │ │ ├── qv/
│ │ │ │ ├── arm/
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── dpp-qv.uvoptx
│ │ │ │ │ └── dpp-qv.uvprojx
│ │ │ │ ├── armclang/
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── dpp-qv.uvoptx
│ │ │ │ │ └── dpp-qv.uvprojx
│ │ │ │ ├── bsp.c
│ │ │ │ ├── gnu/
│ │ │ │ │ ├── .ccsproject
│ │ │ │ │ ├── .cproject
│ │ │ │ │ ├── .project
│ │ │ │ │ ├── Makefile
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── dpp-qv.ld
│ │ │ │ │ └── flash.bat
│ │ │ │ └── iar/
│ │ │ │ ├── README.txt
│ │ │ │ ├── dpp-qv.ewd
│ │ │ │ ├── dpp-qv.ewp
│ │ │ │ ├── dpp-qv.eww
│ │ │ │ └── dpp-qv.icf
│ │ │ └── table.c
│ │ ├── dpp_mbed-lpc1768/
│ │ │ ├── README.txt
│ │ │ ├── README.url
│ │ │ ├── bsp.h
│ │ │ ├── dpp.h
│ │ │ ├── dpp.qm
│ │ │ ├── main.c
│ │ │ ├── philo.c
│ │ │ ├── qk/
│ │ │ │ ├── armclang/
│ │ │ │ │ ├── dpp-qk.uvoptx
│ │ │ │ │ └── dpp-qk.uvprojx
│ │ │ │ ├── bsp.c
│ │ │ │ ├── gnu/
│ │ │ │ │ ├── Makefile
│ │ │ │ │ └── dpp-qk.ld
│ │ │ │ └── iar/
│ │ │ │ ├── dpp-qk.ewd
│ │ │ │ ├── dpp-qk.ewp
│ │ │ │ ├── dpp-qk.eww
│ │ │ │ └── dpp-qk.icf
│ │ │ ├── qpn_conf.h
│ │ │ ├── qv/
│ │ │ │ ├── armclang/
│ │ │ │ │ ├── dpp-qv.uvoptx
│ │ │ │ │ └── dpp-qv.uvprojx
│ │ │ │ ├── bsp.c
│ │ │ │ ├── gnu/
│ │ │ │ │ ├── Makefile
│ │ │ │ │ └── dpp-qv.ld
│ │ │ │ └── iar/
│ │ │ │ ├── dpp-qv.ewd
│ │ │ │ ├── dpp-qv.ewp
│ │ │ │ ├── dpp-qv.eww
│ │ │ │ └── dpp-qv.icf
│ │ │ └── table.c
│ │ ├── dpp_nucleo-l053r8/
│ │ │ ├── README.txt
│ │ │ ├── README.url
│ │ │ ├── bsp.h
│ │ │ ├── dpp.h
│ │ │ ├── dpp.qm
│ │ │ ├── main.c
│ │ │ ├── philo.c
│ │ │ ├── qk/
│ │ │ │ ├── armclang/
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── dpp-qk.uvoptx
│ │ │ │ │ └── dpp-qk.uvprojx
│ │ │ │ ├── bsp.c
│ │ │ │ ├── gnu/
│ │ │ │ │ ├── .cproject
│ │ │ │ │ ├── .project
│ │ │ │ │ ├── Makefile
│ │ │ │ │ ├── dpp-qk.ld
│ │ │ │ │ ├── dpp-qk_nucleo-l053r8.elf.launch
│ │ │ │ │ └── stm32_flash.ld
│ │ │ │ └── iar/
│ │ │ │ ├── dpp-qk.ewd
│ │ │ │ ├── dpp-qk.ewp
│ │ │ │ ├── dpp-qk.eww
│ │ │ │ └── dpp-qk.icf
│ │ │ ├── qpn_conf.h
│ │ │ ├── qv/
│ │ │ │ ├── armclang/
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── dpp-qv.uvoptx
│ │ │ │ │ └── dpp-qv.uvprojx
│ │ │ │ ├── bsp.c
│ │ │ │ ├── gnu/
│ │ │ │ │ ├── .cproject
│ │ │ │ │ ├── .project
│ │ │ │ │ ├── Makefile
│ │ │ │ │ └── dpp-qv.ld
│ │ │ │ └── iar/
│ │ │ │ ├── dpp-qv.ewd
│ │ │ │ ├── dpp-qv.ewp
│ │ │ │ ├── dpp-qv.eww
│ │ │ │ └── dpp-qv.icf
│ │ │ └── table.c
│ │ ├── dpp_nucleo-l152re/
│ │ │ ├── README.txt
│ │ │ ├── README.url
│ │ │ ├── bsp.h
│ │ │ ├── dpp.h
│ │ │ ├── dpp.qm
│ │ │ ├── main.c
│ │ │ ├── philo.c
│ │ │ ├── qk/
│ │ │ │ ├── armclang/
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── dpp-qk.uvoptx
│ │ │ │ │ └── dpp-qk.uvprojx
│ │ │ │ ├── bsp.c
│ │ │ │ ├── gnu/
│ │ │ │ │ ├── .cproject
│ │ │ │ │ ├── .project
│ │ │ │ │ ├── Makefile
│ │ │ │ │ └── dpp-qk.ld
│ │ │ │ └── iar/
│ │ │ │ ├── dpp-qk.ewd
│ │ │ │ ├── dpp-qk.ewp
│ │ │ │ ├── dpp-qk.eww
│ │ │ │ └── dpp-qk.icf
│ │ │ ├── qpn_conf.h
│ │ │ ├── qv/
│ │ │ │ ├── armclang/
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── dpp-qv.uvoptx
│ │ │ │ │ └── dpp-qv.uvprojx
│ │ │ │ ├── bsp.c
│ │ │ │ ├── gnu/
│ │ │ │ │ ├── .cproject
│ │ │ │ │ ├── .project
│ │ │ │ │ ├── Makefile
│ │ │ │ │ └── dpp-qv.ld
│ │ │ │ └── iar/
│ │ │ │ ├── dpp-qv.ewd
│ │ │ │ ├── dpp-qv.ewp
│ │ │ │ ├── dpp-qv.eww
│ │ │ │ └── dpp-qv.icf
│ │ │ └── table.c
│ │ ├── game_efm32-slstk3401a/
│ │ │ ├── README.txt
│ │ │ ├── README.url
│ │ │ ├── bsp.h
│ │ │ ├── game.h
│ │ │ ├── game.qm
│ │ │ ├── main.c
│ │ │ ├── mine1.c
│ │ │ ├── mine2.c
│ │ │ ├── missile.c
│ │ │ ├── qk/
│ │ │ │ ├── armclang/
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── game-qk.uvoptx
│ │ │ │ │ └── game-qk.uvprojx
│ │ │ │ ├── bsp.c
│ │ │ │ ├── gnu/
│ │ │ │ │ ├── Makefile
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── flash.bat
│ │ │ │ │ └── game-qk.ld
│ │ │ │ └── iar/
│ │ │ │ ├── README.txt
│ │ │ │ ├── game-qk.ewd
│ │ │ │ ├── game-qk.ewp
│ │ │ │ ├── game-qk.eww
│ │ │ │ └── game-qk.icf
│ │ │ ├── qpn_conf.h
│ │ │ ├── qv/
│ │ │ │ ├── armclang/
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── game-qv.uvoptx
│ │ │ │ │ └── game-qv.uvprojx
│ │ │ │ ├── bsp.c
│ │ │ │ ├── gnu/
│ │ │ │ │ ├── Makefile
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── flash.bat
│ │ │ │ │ └── game-qv.ld
│ │ │ │ └── iar/
│ │ │ │ ├── README.txt
│ │ │ │ ├── game-qv.ewd
│ │ │ │ ├── game-qv.ewp
│ │ │ │ ├── game-qv.eww
│ │ │ │ └── game-qv.icf
│ │ │ ├── ship.c
│ │ │ ├── tunnel.c
│ │ │ └── win32-gui/
│ │ │ ├── Resource.rc
│ │ │ ├── bsp.c
│ │ │ ├── game-gui.sln
│ │ │ ├── game-gui.vcxproj
│ │ │ ├── game-gui.vcxproj.filters
│ │ │ └── resource.h
│ │ └── pelican_ek-tm4c123gxl/
│ │ ├── README.url
│ │ ├── bsp.h
│ │ ├── main.c
│ │ ├── pelican.c
│ │ ├── pelican.h
│ │ ├── pelican.qm
│ │ ├── qk/
│ │ │ ├── armclang/
│ │ │ │ ├── README.txt
│ │ │ │ ├── pelican-qk.uvoptx
│ │ │ │ └── pelican-qk.uvprojx
│ │ │ ├── bsp.c
│ │ │ ├── gnu/
│ │ │ │ ├── Makefile
│ │ │ │ ├── README.txt
│ │ │ │ ├── flash.bat
│ │ │ │ └── pelican-qk.ld
│ │ │ └── iar/
│ │ │ ├── README.txt
│ │ │ ├── pelican-qk.ewd
│ │ │ ├── pelican-qk.ewp
│ │ │ ├── pelican-qk.eww
│ │ │ └── pelican-qk.icf
│ │ ├── qpn_conf.h
│ │ └── qv/
│ │ ├── armclang/
│ │ │ ├── README.txt
│ │ │ ├── pelican-qv.uvoptx
│ │ │ └── pelican-qv.uvprojx
│ │ ├── bsp.c
│ │ ├── gnu/
│ │ │ ├── Makefile
│ │ │ ├── README.txt
│ │ │ ├── flash.bat
│ │ │ └── pelican-qv.ld
│ │ └── iar/
│ │ ├── README.txt
│ │ ├── pelican-qv.ewd
│ │ ├── pelican-qv.ewp
│ │ ├── pelican-qv.eww
│ │ └── pelican-qv.icf
│ ├── arm7-9/
│ │ ├── README.url
│ │ └── dpp_at91sam7s-ek/
│ │ ├── README.url
│ │ ├── bsp.h
│ │ ├── dpp.h
│ │ ├── dpp.qm
│ │ ├── main.c
│ │ ├── philo.c
│ │ ├── qk/
│ │ │ └── iar/
│ │ │ ├── at91SAM7S64.icf
│ │ │ ├── bsp.c
│ │ │ ├── dpp-qk.ewd
│ │ │ ├── dpp-qk.ewp
│ │ │ └── dpp-qk.eww
│ │ ├── qpn_conf.h
│ │ ├── qv/
│ │ │ └── iar/
│ │ │ ├── at91SAM7S64.icf
│ │ │ ├── bsp.c
│ │ │ ├── dpp-qv.ewd
│ │ │ ├── dpp-qv.ewp
│ │ │ └── dpp-qv.eww
│ │ └── table.c
│ ├── avr/
│ │ ├── README.url
│ │ ├── blinky_arduino-uno/
│ │ │ ├── README.url
│ │ │ ├── blinky.c
│ │ │ ├── blinky.h
│ │ │ ├── bsp.h
│ │ │ ├── main.c
│ │ │ ├── qk/
│ │ │ │ ├── gnu/
│ │ │ │ │ ├── Makefile
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── bsp.c
│ │ │ │ │ └── flash.bat
│ │ │ │ └── iar/
│ │ │ │ ├── blinky-qk.ewd
│ │ │ │ ├── blinky-qk.ewp
│ │ │ │ ├── blinky-qk.eww
│ │ │ │ ├── bsp.c
│ │ │ │ └── flash.bat
│ │ │ ├── qpn_conf.h
│ │ │ └── qv/
│ │ │ ├── gnu/
│ │ │ │ ├── Makefile
│ │ │ │ ├── README.txt
│ │ │ │ ├── bsp.c
│ │ │ │ └── flash.bat
│ │ │ └── iar/
│ │ │ ├── blinky-qv.ewd
│ │ │ ├── blinky-qv.ewp
│ │ │ ├── blinky-qv.eww
│ │ │ ├── bsp.c
│ │ │ └── flash.bat
│ │ └── dpp_arduino-uno/
│ │ ├── README.url
│ │ ├── bsp.h
│ │ ├── dpp.h
│ │ ├── dpp.qm
│ │ ├── main.c
│ │ ├── philo.c
│ │ ├── qk/
│ │ │ ├── gnu/
│ │ │ │ ├── Makefile
│ │ │ │ ├── README.txt
│ │ │ │ ├── bsp.c
│ │ │ │ └── flash.bat
│ │ │ └── iar/
│ │ │ ├── README.txt
│ │ │ ├── bsp.c
│ │ │ ├── dpp-qk.ewd
│ │ │ ├── dpp-qk.ewp
│ │ │ ├── dpp-qk.eww
│ │ │ ├── flash.bat
│ │ │ └── spy.bat
│ │ ├── qpn_conf.h
│ │ ├── qv/
│ │ │ ├── gnu/
│ │ │ │ ├── Makefile
│ │ │ │ ├── README.txt
│ │ │ │ ├── bsp.c
│ │ │ │ ├── flash.bat
│ │ │ │ └── spy.bat
│ │ │ └── iar/
│ │ │ ├── README.txt
│ │ │ ├── bsp.c
│ │ │ ├── dpp-qv.ewd
│ │ │ ├── dpp-qv.ewp
│ │ │ ├── dpp-qv.eww
│ │ │ ├── flash.bat
│ │ │ └── spy.bat
│ │ └── table.c
│ ├── msp430/
│ │ ├── README.url
│ │ ├── blinky_msp-exp430f5529lp/
│ │ │ ├── README.url
│ │ │ ├── blinky.c
│ │ │ ├── blinky.h
│ │ │ ├── bsp.h
│ │ │ ├── main.c
│ │ │ ├── qk/
│ │ │ │ ├── bsp.c
│ │ │ │ ├── ccs/
│ │ │ │ │ ├── .ccsproject
│ │ │ │ │ ├── .cproject
│ │ │ │ │ ├── .project
│ │ │ │ │ └── lnk_msp430f5529.cmd
│ │ │ │ └── iar/
│ │ │ │ ├── blinky-qk.ewd
│ │ │ │ ├── blinky-qk.ewp
│ │ │ │ └── blinky-qk.eww
│ │ │ ├── qpn_conf.h
│ │ │ └── qv/
│ │ │ ├── bsp.c
│ │ │ ├── ccs/
│ │ │ │ ├── .ccsproject
│ │ │ │ ├── .cproject
│ │ │ │ ├── .project
│ │ │ │ └── lnk_msp430f5529.cmd
│ │ │ └── iar/
│ │ │ ├── blinky-qv.ewd
│ │ │ ├── blinky-qv.ewp
│ │ │ └── blinky-qv.eww
│ │ ├── blinky_msp-exp430g2/
│ │ │ ├── README.url
│ │ │ ├── blinky.c
│ │ │ ├── blinky.h
│ │ │ ├── bsp.h
│ │ │ ├── main.c
│ │ │ ├── qk/
│ │ │ │ ├── bsp.c
│ │ │ │ ├── ccs/
│ │ │ │ │ ├── .ccsproject
│ │ │ │ │ ├── .cproject
│ │ │ │ │ ├── .project
│ │ │ │ │ └── lnk_msp430g2553.cmd
│ │ │ │ └── iar/
│ │ │ │ ├── blinky-qk.ewd
│ │ │ │ ├── blinky-qk.ewp
│ │ │ │ └── blinky-qk.eww
│ │ │ ├── qpn_conf.h
│ │ │ └── qv/
│ │ │ ├── bsp.c
│ │ │ ├── ccs/
│ │ │ │ ├── .ccsproject
│ │ │ │ ├── .cproject
│ │ │ │ ├── .project
│ │ │ │ └── lnk_msp430g2553.cmd
│ │ │ └── iar/
│ │ │ ├── blinky-qv.ewd
│ │ │ ├── blinky-qv.ewp
│ │ │ └── blinky-qv.eww
│ │ └── dpp_msp-exp430g2/
│ │ ├── README.url
│ │ ├── bsp.h
│ │ ├── dpp.h
│ │ ├── dpp.qm
│ │ ├── main.c
│ │ ├── philo.c
│ │ ├── qk/
│ │ │ ├── bsp.c
│ │ │ ├── ccs/
│ │ │ │ ├── .ccsproject
│ │ │ │ ├── .cproject
│ │ │ │ ├── .project
│ │ │ │ └── lnk_msp430g2553.cmd
│ │ │ └── iar/
│ │ │ ├── dpp-qk.ewd
│ │ │ ├── dpp-qk.ewp
│ │ │ └── dpp-qk.eww
│ │ ├── qpn_conf.h
│ │ ├── qv/
│ │ │ ├── bsp.c
│ │ │ ├── ccs/
│ │ │ │ ├── .ccsproject
│ │ │ │ ├── .cproject
│ │ │ │ ├── .project
│ │ │ │ └── lnk_msp430g2553.cmd
│ │ │ └── iar/
│ │ │ ├── dpp-qv.ewd
│ │ │ ├── dpp-qv.ewp
│ │ │ └── dpp-qv.eww
│ │ └── table.c
│ ├── pic24_dspic/
│ │ ├── blinky_microstick2-pic24/
│ │ │ ├── blinky.c
│ │ │ ├── blinky.h
│ │ │ ├── bsp.h
│ │ │ ├── main.c
│ │ │ ├── qk/
│ │ │ │ └── xc16/
│ │ │ │ ├── Makefile
│ │ │ │ ├── bsp.c
│ │ │ │ └── nbproject/
│ │ │ │ ├── Makefile-default.mk
│ │ │ │ ├── Makefile-genesis.properties
│ │ │ │ ├── Makefile-impl.mk
│ │ │ │ ├── Makefile-local-default.mk
│ │ │ │ ├── Makefile-local-release.mk
│ │ │ │ ├── Makefile-release.mk
│ │ │ │ ├── Makefile-variables.mk
│ │ │ │ ├── Package-default.bash
│ │ │ │ ├── Package-release.bash
│ │ │ │ ├── configurations.xml
│ │ │ │ ├── private/
│ │ │ │ │ ├── configurations.xml
│ │ │ │ │ ├── private.properties
│ │ │ │ │ └── private.xml
│ │ │ │ ├── project.properties
│ │ │ │ └── project.xml
│ │ │ ├── qpn_conf.h
│ │ │ └── qv/
│ │ │ └── xc16/
│ │ │ ├── Makefile
│ │ │ ├── bsp.c
│ │ │ └── nbproject/
│ │ │ ├── Makefile-default.mk
│ │ │ ├── Makefile-genesis.properties
│ │ │ ├── Makefile-impl.mk
│ │ │ ├── Makefile-local-default.mk
│ │ │ ├── Makefile-local-release.mk
│ │ │ ├── Makefile-release.mk
│ │ │ ├── Makefile-variables.mk
│ │ │ ├── Package-default.bash
│ │ │ ├── Package-release.bash
│ │ │ ├── configurations.xml
│ │ │ ├── private/
│ │ │ │ ├── configurations.xml
│ │ │ │ ├── private.properties
│ │ │ │ └── private.xml
│ │ │ ├── project.properties
│ │ │ └── project.xml
│ │ ├── dpp_microstick2-pic24/
│ │ │ ├── bsp.h
│ │ │ ├── dpp.h
│ │ │ ├── dpp.qm
│ │ │ ├── main.c
│ │ │ ├── philo.c
│ │ │ ├── qk/
│ │ │ │ └── xc16/
│ │ │ │ ├── Makefile
│ │ │ │ ├── bsp.c
│ │ │ │ └── nbproject/
│ │ │ │ ├── Makefile-default.mk
│ │ │ │ ├── Makefile-genesis.properties
│ │ │ │ ├── Makefile-impl.mk
│ │ │ │ ├── Makefile-local-default.mk
│ │ │ │ ├── Makefile-local-release.mk
│ │ │ │ ├── Makefile-release.mk
│ │ │ │ ├── Makefile-variables.mk
│ │ │ │ ├── Package-default.bash
│ │ │ │ ├── Package-release.bash
│ │ │ │ ├── configurations.xml
│ │ │ │ ├── private/
│ │ │ │ │ ├── configurations.xml
│ │ │ │ │ ├── private.properties
│ │ │ │ │ └── private.xml
│ │ │ │ ├── project.properties
│ │ │ │ └── project.xml
│ │ │ ├── qpn_conf.h
│ │ │ ├── qv/
│ │ │ │ └── xc16/
│ │ │ │ ├── Makefile
│ │ │ │ ├── bsp.c
│ │ │ │ └── nbproject/
│ │ │ │ ├── Makefile-default.mk
│ │ │ │ ├── Makefile-genesis.properties
│ │ │ │ ├── Makefile-impl.mk
│ │ │ │ ├── Makefile-local-default.mk
│ │ │ │ ├── Makefile-local-release.mk
│ │ │ │ ├── Makefile-release.mk
│ │ │ │ ├── Makefile-variables.mk
│ │ │ │ ├── Package-default.bash
│ │ │ │ ├── Package-release.bash
│ │ │ │ ├── configurations.xml
│ │ │ │ ├── private/
│ │ │ │ │ ├── configurations.xml
│ │ │ │ │ ├── private.properties
│ │ │ │ │ └── private.xml
│ │ │ │ ├── project.properties
│ │ │ │ └── project.xml
│ │ │ └── table.c
│ │ └── pelican_microstick2-pic24/
│ │ ├── bsp.h
│ │ ├── main.c
│ │ ├── pelican.c
│ │ ├── pelican.h
│ │ ├── pelican.qm
│ │ ├── qk/
│ │ │ └── xc16/
│ │ │ ├── Makefile
│ │ │ ├── bsp.c
│ │ │ └── nbproject/
│ │ │ ├── Makefile-default.mk
│ │ │ ├── Makefile-genesis.properties
│ │ │ ├── Makefile-impl.mk
│ │ │ ├── Makefile-local-default.mk
│ │ │ ├── Makefile-local-release.mk
│ │ │ ├── Makefile-release.mk
│ │ │ ├── Makefile-variables.mk
│ │ │ ├── Package-default.bash
│ │ │ ├── Package-release.bash
│ │ │ ├── configurations.xml
│ │ │ ├── private/
│ │ │ │ ├── configurations.xml
│ │ │ │ ├── private.properties
│ │ │ │ └── private.xml
│ │ │ ├── project.properties
│ │ │ └── project.xml
│ │ ├── qpn_conf.h
│ │ └── qv/
│ │ └── xc16/
│ │ ├── Makefile
│ │ ├── bsp.c
│ │ └── nbproject/
│ │ ├── Makefile-default.mk
│ │ ├── Makefile-genesis.properties
│ │ ├── Makefile-impl.mk
│ │ ├── Makefile-local-default.mk
│ │ ├── Makefile-local-release.mk
│ │ ├── Makefile-release.mk
│ │ ├── Makefile-variables.mk
│ │ ├── Package-default.bash
│ │ ├── Package-release.bash
│ │ ├── configurations.xml
│ │ ├── private/
│ │ │ ├── configurations.xml
│ │ │ ├── private.properties
│ │ │ └── private.xml
│ │ ├── project.properties
│ │ └── project.xml
│ └── workstation/
│ ├── README.txt
│ ├── blinky/
│ │ ├── Makefile
│ │ ├── README.txt
│ │ ├── blinky.c
│ │ ├── blinky.qm
│ │ └── qpn_conf.h
│ ├── calc/
│ │ ├── Makefile
│ │ ├── bsp.c
│ │ ├── bsp.h
│ │ ├── calc.c
│ │ ├── calc.h
│ │ ├── calc.qm
│ │ ├── main.c
│ │ └── qpn_conf.h
│ ├── comp/
│ │ ├── Makefile
│ │ ├── alarm.c
│ │ ├── alarm.h
│ │ ├── bsp.c
│ │ ├── bsp.h
│ │ ├── clock.h
│ │ ├── comp.c
│ │ ├── main.c
│ │ └── qpn_conf.h
│ ├── defer/
│ │ ├── Makefile
│ │ ├── bsp.c
│ │ ├── bsp.h
│ │ ├── defer.c
│ │ ├── defer.h
│ │ ├── main.c
│ │ └── qpn_conf.h
│ ├── dpp/
│ │ ├── Makefile
│ │ ├── bsp.c
│ │ ├── bsp.h
│ │ ├── dpp.h
│ │ ├── dpp.qm
│ │ ├── dpp.sln
│ │ ├── dpp.vcxproj
│ │ ├── dpp.vcxproj.filters
│ │ ├── main.c
│ │ ├── philo.c
│ │ ├── qpn_conf.h
│ │ └── table.c
│ ├── dpp-comp/
│ │ ├── Makefile
│ │ ├── bsp.c
│ │ ├── bsp.h
│ │ ├── dpp.h
│ │ ├── dpp.sln
│ │ ├── dpp.vcxproj
│ │ ├── dpp.vcxproj.filters
│ │ ├── dpp_comp.qm
│ │ ├── main.c
│ │ ├── philo.c
│ │ ├── qpn_conf.h
│ │ └── table.c
│ ├── dpp-gui/
│ │ └── README.txt
│ ├── game-gui/
│ │ └── README.txt
│ ├── history/
│ │ ├── Makefile
│ │ ├── bsp.c
│ │ ├── bsp.h
│ │ ├── history.c
│ │ ├── history.h
│ │ ├── history.qm
│ │ ├── main.c
│ │ └── qpn_conf.h
│ ├── pelican/
│ │ ├── Makefile
│ │ ├── bsp.c
│ │ ├── bsp.h
│ │ ├── main.c
│ │ ├── pelican.c
│ │ ├── pelican.h
│ │ ├── pelican.qm
│ │ └── qpn_conf.h
│ ├── qhsmtst/
│ │ ├── Makefile
│ │ ├── bsp.c
│ │ ├── bsp.h
│ │ ├── log.txt
│ │ ├── main.c
│ │ ├── qhsmtst.c
│ │ ├── qhsmtst.h
│ │ ├── qhsmtst.qm
│ │ └── qpn_conf.h
│ ├── reminder/
│ │ ├── Makefile
│ │ ├── bsp.c
│ │ ├── bsp.h
│ │ ├── main.c
│ │ ├── qpn_conf.h
│ │ ├── reminder.c
│ │ └── reminder.h
│ └── reminder2/
│ ├── Makefile
│ ├── bsp.c
│ ├── bsp.h
│ ├── main.c
│ ├── qpn_conf.h
│ ├── reminder2.c
│ └── reminder2.h
├── include/
│ ├── qassert.h
│ ├── qepn.h
│ ├── qfn.h
│ ├── qkn.h
│ ├── qpn.h
│ ├── qstamp.c
│ └── qvn.h
├── ports/
│ ├── README.url
│ ├── arm-cm/
│ │ ├── README.url
│ │ ├── qk/
│ │ │ ├── arm/
│ │ │ │ ├── qfn_port.h
│ │ │ │ └── qkn_port.c
│ │ │ ├── armclang/
│ │ │ │ ├── qfn_port.h
│ │ │ │ └── qkn_port.c
│ │ │ ├── gnu/
│ │ │ │ ├── qfn_port.h
│ │ │ │ └── qkn_port.c
│ │ │ └── iar/
│ │ │ ├── qfn_port.h
│ │ │ └── qkn_port.c
│ │ └── qv/
│ │ ├── arm/
│ │ │ ├── qfn_port.h
│ │ │ └── qvn_port.c
│ │ ├── armclang/
│ │ │ ├── qfn_port.h
│ │ │ └── qvn_port.c
│ │ ├── gnu/
│ │ │ ├── qfn_port.h
│ │ │ └── qvn_port.c
│ │ └── iar/
│ │ ├── qfn_port.h
│ │ └── qvn_port.c
│ ├── arm7-9/
│ │ ├── README.url
│ │ ├── qk/
│ │ │ ├── README.url
│ │ │ ├── gnu/
│ │ │ │ ├── qfn_port.h
│ │ │ │ └── qkn_port.s
│ │ │ └── iar/
│ │ │ ├── qfn_port.h
│ │ │ └── qkn_port.s
│ │ └── qv/
│ │ ├── README.url
│ │ ├── gnu/
│ │ │ ├── qfn_port.h
│ │ │ └── qvn_port.s
│ │ └── iar/
│ │ ├── qfn_port.h
│ │ └── qvn_port.s
│ ├── avr/
│ │ ├── README.txt
│ │ ├── README.url
│ │ ├── qk/
│ │ │ ├── gnu/
│ │ │ │ ├── README.txt
│ │ │ │ └── qfn_port.h
│ │ │ └── iar/
│ │ │ └── qfn_port.h
│ │ └── qv/
│ │ ├── gnu/
│ │ │ ├── README.txt
│ │ │ └── qfn_port.h
│ │ └── iar/
│ │ └── qfn_port.h
│ ├── lint-plus/
│ │ ├── 16bit/
│ │ │ ├── cpu.lnt
│ │ │ └── stdint.h
│ │ ├── 32bit/
│ │ │ ├── cpu.lnt
│ │ │ └── stdint.h
│ │ ├── au-ds.lnt
│ │ ├── au-misra3-amd1.lnt
│ │ ├── au-misra3.lnt
│ │ ├── lin.bat
│ │ ├── options.lnt
│ │ ├── qkn/
│ │ │ └── qfn_port.h
│ │ ├── qpn.lnt
│ │ ├── qpn_conf.h
│ │ ├── qvn/
│ │ │ └── qfn_port.h
│ │ ├── std.lnt
│ │ └── stdbool.h
│ ├── msp430/
│ │ ├── README.txt
│ │ ├── README.url
│ │ ├── qk/
│ │ │ ├── ccs/
│ │ │ │ ├── README.txt
│ │ │ │ └── qfn_port.h
│ │ │ └── iar/
│ │ │ └── qfn_port.h
│ │ └── qv/
│ │ ├── ccs/
│ │ │ ├── README.txt
│ │ │ └── qfn_port.h
│ │ └── iar/
│ │ └── qfn_port.h
│ ├── pic24_dspic/
│ │ ├── qk/
│ │ │ └── xc16/
│ │ │ ├── qfn_port.h
│ │ │ └── qkn_port.c
│ │ └── qv/
│ │ └── xc16/
│ │ └── qfn_port.h
│ ├── posix-qv/
│ │ ├── README.url
│ │ ├── qfn_port.h
│ │ ├── qfn_posix.c
│ │ └── safe_std.h
│ └── win32-qv/
│ ├── README.url
│ ├── qfn_port.h
│ ├── qfn_win32.c
│ ├── qwin_gui.c
│ ├── qwin_gui.h
│ └── safe_std.h
└── src/
├── qfn/
│ ├── qepn.c
│ └── qfn.c
├── qkn/
│ └── qkn.c
└── qvn/
└── qvn.c
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitignore
================================================
*.obj
*.o
*.d
*.lib
*.a
*.elf
*.err
*.hex
*.exe
*.EXE
*.map
*.dep
*.pdf
*.PDF
*.Hbp
*.nav
*.tps
*.tws
*.tmp
*.log
*.chm
*.zip
*.pdb
*.ncb
*.suo
*.chw
*.sfr
*.ewt
*.user
*.avrsuo
*.Debug
*.Release
lint*.txt
*.Miro
*.bak
*.qlc
JLink*.*
version-*
metrics.dox
html/
test_priv/
dbg/
rel/
spy/
build/
build_rel/
build_spy/
settings/
.settings/
targetConfigs/
Debug/
Release/
lib/
obj/
output/
================================================
FILE: .gitmodules
================================================
[submodule "3rd_party"]
path = 3rd_party
url = https://github.com/QuantumLeaps/3rd_party-qpn.git
================================================
FILE: GPLv3.txt
================================================
GNU GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The GNU General Public License is a free, copyleft license for
software and other kinds of works.
The licenses for most software and other practical works are designed
to take away your freedom to share and change the works. By contrast,
the GNU General Public License is intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users. We, the Free Software Foundation, use the
GNU General Public License for most of our software; it applies also to
any other work released this way by its authors. You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
them if you wish), that you receive source code or can get it if you
want it, that you can change the software or use pieces of it in new
free programs, and that you know you can do these things.
To protect your rights, we need to prevent others from denying you
these rights or asking you to surrender the rights. Therefore, you have
certain responsibilities if you distribute copies of the software, or if
you modify it: responsibilities to respect the freedom of others.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must pass on to the recipients the same
freedoms that you received. You must make sure that they, too, receive
or can get the source code. And you must show them these terms so they
know their rights.
Developers that use the GNU GPL protect your rights with two steps:
(1) assert copyright on the software, and (2) offer you this License
giving you legal permission to copy, distribute and/or modify it.
For the developers' and authors' protection, the GPL clearly explains
that there is no warranty for this free software. For both users' and
authors' sake, the GPL requires that modified versions be marked as
changed, so that their problems will not be attributed erroneously to
authors of previous versions.
Some devices are designed to deny users access to install or run
modified versions of the software inside them, although the manufacturer
can do so. This is fundamentally incompatible with the aim of
protecting users' freedom to change the software. The systematic
pattern of such abuse occurs in the area of products for individuals to
use, which is precisely where it is most unacceptable. Therefore, we
have designed this version of the GPL to prohibit the practice for those
products. If such problems arise substantially in other domains, we
stand ready to extend this provision to those domains in future versions
of the GPL, as needed to protect the freedom of users.
Finally, every program is threatened constantly by software patents.
States should not allow patents to restrict development and use of
software on general-purpose computers, but in those that do, we wish to
avoid the special danger that patents applied to a free program could
make it effectively proprietary. To prevent this, the GPL assures that
patents cannot be used to render the program non-free.
The precise terms and conditions for copying, distribution and
modification follow.
TERMS AND CONDITIONS
0. Definitions.
"This License" refers to version 3 of the GNU General Public License.
"Copyright" also means copyright-like laws that apply to other kinds of
works, such as semiconductor masks.
"The Program" refers to any copyrightable work licensed under this
License. Each licensee is addressed as "you". "Licensees" and
"recipients" may be individuals or organizations.
To "modify" a work means to copy from or adapt all or part of the work
in a fashion requiring copyright permission, other than the making of an
exact copy. The resulting work is called a "modified version" of the
earlier work or a work "based on" the earlier work.
A "covered work" means either the unmodified Program or a work based
on the Program.
To "propagate" a work means to do anything with it that, without
permission, would make you directly or secondarily liable for
infringement under applicable copyright law, except executing it on a
computer or modifying a private copy. Propagation includes copying,
distribution (with or without modification), making available to the
public, and in some countries other activities as well.
To "convey" a work means any kind of propagation that enables other
parties to make or receive copies. Mere interaction with a user through
a computer network, with no transfer of a copy, is not conveying.
An interactive user interface displays "Appropriate Legal Notices"
to the extent that it includes a convenient and prominently visible
feature that (1) displays an appropriate copyright notice, and (2)
tells the user that there is no warranty for the work (except to the
extent that warranties are provided), that licensees may convey the
work under this License, and how to view a copy of this License. If
the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.
1. Source Code.
The "source code" for a work means the preferred form of the work
for making modifications to it. "Object code" means any non-source
form of a work.
A "Standard Interface" means an interface that either is an official
standard defined by a recognized standards body, or, in the case of
interfaces specified for a particular programming language, one that
is widely used among developers working in that language.
The "System Libraries" of an executable work include anything, other
than the work as a whole, that (a) is included in the normal form of
packaging a Major Component, but which is not part of that Major
Component, and (b) serves only to enable use of the work with that
Major Component, or to implement a Standard Interface for which an
implementation is available to the public in source code form. A
"Major Component", in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system
(if any) on which the executable work runs, or a compiler used to
produce the work, or an object code interpreter used to run it.
The "Corresponding Source" for a work in object code form means all
the source code needed to generate, install, and (for an executable
work) run the object code and to modify the work, including scripts to
control those activities. However, it does not include the work's
System Libraries, or general-purpose tools or generally available free
programs which are used unmodified in performing those activities but
which are not part of the work. For example, Corresponding Source
includes interface definition files associated with source files for
the work, and the source code for shared libraries and dynamically
linked subprograms that the work is specifically designed to require,
such as by intimate data communication or control flow between those
subprograms and other parts of the work.
The Corresponding Source need not include anything that users
can regenerate automatically from other parts of the Corresponding
Source.
The Corresponding Source for a work in source code form is that
same work.
2. Basic Permissions.
All rights granted under this License are granted for the term of
copyright on the Program, and are irrevocable provided the stated
conditions are met. This License explicitly affirms your unlimited
permission to run the unmodified Program. The output from running a
covered work is covered by this License only if the output, given its
content, constitutes a covered work. This License acknowledges your
rights of fair use or other equivalent, as provided by copyright law.
You may make, run and propagate covered works that you do not
convey, without conditions so long as your license otherwise remains
in force. You may convey covered works to others for the sole purpose
of having them make modifications exclusively for you, or provide you
with facilities for running those works, provided that you comply with
the terms of this License in conveying all material for which you do
not control copyright. Those thus making or running the covered works
for you must do so exclusively on your behalf, under your direction
and control, on terms that prohibit them from making any copies of
your copyrighted material outside their relationship with you.
Conveying under any other circumstances is permitted solely under
the conditions stated below. Sublicensing is not allowed; section 10
makes it unnecessary.
3. Protecting Users' Legal Rights From Anti-Circumvention Law.
No covered work shall be deemed part of an effective technological
measure under any applicable law fulfilling obligations under article
11 of the WIPO copyright treaty adopted on 20 December 1996, or
similar laws prohibiting or restricting circumvention of such
measures.
When you convey a covered work, you waive any legal power to forbid
circumvention of technological measures to the extent such circumvention
is effected by exercising rights under this License with respect to
the covered work, and you disclaim any intention to limit operation or
modification of the work as a means of enforcing, against the work's
users, your or third parties' legal rights to forbid circumvention of
technological measures.
4. Conveying Verbatim Copies.
You may convey verbatim copies of the Program's source code as you
receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice;
keep intact all notices stating that this License and any
non-permissive terms added in accord with section 7 apply to the code;
keep intact all notices of the absence of any warranty; and give all
recipients a copy of this License along with the Program.
You may charge any price or no price for each copy that you convey,
and you may offer support or warranty protection for a fee.
5. Conveying Modified Source Versions.
You may convey a work based on the Program, or the modifications to
produce it from the Program, in the form of source code under the
terms of section 4, provided that you also meet all of these conditions:
a) The work must carry prominent notices stating that you modified
it, and giving a relevant date.
b) The work must carry prominent notices stating that it is
released under this License and any conditions added under section
7. This requirement modifies the requirement in section 4 to
"keep intact all notices".
c) You must license the entire work, as a whole, under this
License to anyone who comes into possession of a copy. This
License will therefore apply, along with any applicable section 7
additional terms, to the whole of the work, and all its parts,
regardless of how they are packaged. This License gives no
permission to license the work in any other way, but it does not
invalidate such permission if you have separately received it.
d) If the work has interactive user interfaces, each must display
Appropriate Legal Notices; however, if the Program has interactive
interfaces that do not display Appropriate Legal Notices, your
work need not make them do so.
A compilation of a covered work with other separate and independent
works, which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium, is called an
"aggregate" if the compilation and its resulting copyright are not
used to limit the access or legal rights of the compilation's users
beyond what the individual works permit. Inclusion of a covered work
in an aggregate does not cause this License to apply to the other
parts of the aggregate.
6. Conveying Non-Source Forms.
You may convey a covered work in object code form under the terms
of sections 4 and 5, provided that you also convey the
machine-readable Corresponding Source under the terms of this License,
in one of these ways:
a) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by the
Corresponding Source fixed on a durable physical medium
customarily used for software interchange.
b) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by a
written offer, valid for at least three years and valid for as
long as you offer spare parts or customer support for that product
model, to give anyone who possesses the object code either (1) a
copy of the Corresponding Source for all the software in the
product that is covered by this License, on a durable physical
medium customarily used for software interchange, for a price no
more than your reasonable cost of physically performing this
conveying of source, or (2) access to copy the
Corresponding Source from a network server at no charge.
c) Convey individual copies of the object code with a copy of the
written offer to provide the Corresponding Source. This
alternative is allowed only occasionally and noncommercially, and
only if you received the object code with such an offer, in accord
with subsection 6b.
d) Convey the object code by offering access from a designated
place (gratis or for a charge), and offer equivalent access to the
Corresponding Source in the same way through the same place at no
further charge. You need not require recipients to copy the
Corresponding Source along with the object code. If the place to
copy the object code is a network server, the Corresponding Source
may be on a different server (operated by you or a third party)
that supports equivalent copying facilities, provided you maintain
clear directions next to the object code saying where to find the
Corresponding Source. Regardless of what server hosts the
Corresponding Source, you remain obligated to ensure that it is
available for as long as needed to satisfy these requirements.
e) Convey the object code using peer-to-peer transmission, provided
you inform other peers where the object code and Corresponding
Source of the work are being offered to the general public at no
charge under subsection 6d.
A separable portion of the object code, whose source code is excluded
from the Corresponding Source as a System Library, need not be
included in conveying the object code work.
A "User Product" is either (1) a "consumer product", which means any
tangible personal property which is normally used for personal, family,
or household purposes, or (2) anything designed or sold for incorporation
into a dwelling. In determining whether a product is a consumer product,
doubtful cases shall be resolved in favor of coverage. For a particular
product received by a particular user, "normally used" refers to a
typical or common use of that class of product, regardless of the status
of the particular user or of the way in which the particular user
actually uses, or expects or is expected to use, the product. A product
is a consumer product regardless of whether the product has substantial
commercial, industrial or non-consumer uses, unless such uses represent
the only significant mode of use of the product.
"Installation Information" for a User Product means any methods,
procedures, authorization keys, or other information required to install
and execute modified versions of a covered work in that User Product from
a modified version of its Corresponding Source. The information must
suffice to ensure that the continued functioning of the modified object
code is in no case prevented or interfered with solely because
modification has been made.
If you convey an object code work under this section in, or with, or
specifically for use in, a User Product, and the conveying occurs as
part of a transaction in which the right of possession and use of the
User Product is transferred to the recipient in perpetuity or for a
fixed term (regardless of how the transaction is characterized), the
Corresponding Source conveyed under this section must be accompanied
by the Installation Information. But this requirement does not apply
if neither you nor any third party retains the ability to install
modified object code on the User Product (for example, the work has
been installed in ROM).
The requirement to provide Installation Information does not include a
requirement to continue to provide support service, warranty, or updates
for a work that has been modified or installed by the recipient, or for
the User Product in which it has been modified or installed. Access to a
network may be denied when the modification itself materially and
adversely affects the operation of the network or violates the rules and
protocols for communication across the network.
Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.
7. Additional Terms.
"Additional permissions" are terms that supplement the terms of this
License by making exceptions from one or more of its conditions.
Additional permissions that are applicable to the entire Program shall
be treated as though they were included in this License, to the extent
that they are valid under applicable law. If additional permissions
apply only to part of the Program, that part may be used separately
under those permissions, but the entire Program remains governed by
this License without regard to the additional permissions.
When you convey a copy of a covered work, you may at your option
remove any additional permissions from that copy, or from any part of
it. (Additional permissions may be written to require their own
removal in certain cases when you modify the work.) You may place
additional permissions on material, added by you to a covered work,
for which you have or can give appropriate copyright permission.
Notwithstanding any other provision of this License, for material you
add to a covered work, you may (if authorized by the copyright holders of
that material) supplement the terms of this License with terms:
a) Disclaiming warranty or limiting liability differently from the
terms of sections 15 and 16 of this License; or
b) Requiring preservation of specified reasonable legal notices or
author attributions in that material or in the Appropriate Legal
Notices displayed by works containing it; or
c) Prohibiting misrepresentation of the origin of that material, or
requiring that modified versions of such material be marked in
reasonable ways as different from the original version; or
d) Limiting the use for publicity purposes of names of licensors or
authors of the material; or
e) Declining to grant rights under trademark law for use of some
trade names, trademarks, or service marks; or
f) Requiring indemnification of licensors and authors of that
material by anyone who conveys the material (or modified versions of
it) with contractual assumptions of liability to the recipient, for
any liability that these contractual assumptions directly impose on
those licensors and authors.
All other non-permissive additional terms are considered "further
restrictions" within the meaning of section 10. If the Program as you
received it, or any part of it, contains a notice stating that it is
governed by this License along with a term that is a further
restriction, you may remove that term. If a license document contains
a further restriction but permits relicensing or conveying under this
License, you may add to a covered work material governed by the terms
of that license document, provided that the further restriction does
not survive such relicensing or conveying.
If you add terms to a covered work in accord with this section, you
must place, in the relevant source files, a statement of the
additional terms that apply to those files, or a notice indicating
where to find the applicable terms.
Additional terms, permissive or non-permissive, may be stated in the
form of a separately written license, or stated as exceptions;
the above requirements apply either way.
8. Termination.
You may not propagate or modify a covered work except as expressly
provided under this License. Any attempt otherwise to propagate or
modify it is void, and will automatically terminate your rights under
this License (including any patent licenses granted under the third
paragraph of section 11).
However, if you cease all violation of this License, then your
license from a particular copyright holder is reinstated (a)
provisionally, unless and until the copyright holder explicitly and
finally terminates your license, and (b) permanently, if the copyright
holder fails to notify you of the violation by some reasonable means
prior to 60 days after the cessation.
Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.
Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License. If your rights have been terminated and not permanently
reinstated, you do not qualify to receive new licenses for the same
material under section 10.
9. Acceptance Not Required for Having Copies.
You are not required to accept this License in order to receive or
run a copy of the Program. Ancillary propagation of a covered work
occurring solely as a consequence of using peer-to-peer transmission
to receive a copy likewise does not require acceptance. However,
nothing other than this License grants you permission to propagate or
modify any covered work. These actions infringe copyright if you do
not accept this License. Therefore, by modifying or propagating a
covered work, you indicate your acceptance of this License to do so.
10. Automatic Licensing of Downstream Recipients.
Each time you convey a covered work, the recipient automatically
receives a license from the original licensors, to run, modify and
propagate that work, subject to this License. You are not responsible
for enforcing compliance by third parties with this License.
An "entity transaction" is a transaction transferring control of an
organization, or substantially all assets of one, or subdividing an
organization, or merging organizations. If propagation of a covered
work results from an entity transaction, each party to that
transaction who receives a copy of the work also receives whatever
licenses to the work the party's predecessor in interest had or could
give under the previous paragraph, plus a right to possession of the
Corresponding Source of the work from the predecessor in interest, if
the predecessor has it or can get it with reasonable efforts.
You may not impose any further restrictions on the exercise of the
rights granted or affirmed under this License. For example, you may
not impose a license fee, royalty, or other charge for exercise of
rights granted under this License, and you may not initiate litigation
(including a cross-claim or counterclaim in a lawsuit) alleging that
any patent claim is infringed by making, using, selling, offering for
sale, or importing the Program or any portion of it.
11. Patents.
A "contributor" is a copyright holder who authorizes use under this
License of the Program or a work on which the Program is based. The
work thus licensed is called the contributor's "contributor version".
A contributor's "essential patent claims" are all patent claims
owned or controlled by the contributor, whether already acquired or
hereafter acquired, that would be infringed by some manner, permitted
by this License, of making, using, or selling its contributor version,
but do not include claims that would be infringed only as a
consequence of further modification of the contributor version. For
purposes of this definition, "control" includes the right to grant
patent sublicenses in a manner consistent with the requirements of
this License.
Each contributor grants you a non-exclusive, worldwide, royalty-free
patent license under the contributor's essential patent claims, to
make, use, sell, offer for sale, import and otherwise run, modify and
propagate the contents of its contributor version.
In the following three paragraphs, a "patent license" is any express
agreement or commitment, however denominated, not to enforce a patent
(such as an express permission to practice a patent or covenant not to
sue for patent infringement). To "grant" such a patent license to a
party means to make such an agreement or commitment not to enforce a
patent against the party.
If you convey a covered work, knowingly relying on a patent license,
and the Corresponding Source of the work is not available for anyone
to copy, free of charge and under the terms of this License, through a
publicly available network server or other readily accessible means,
then you must either (1) cause the Corresponding Source to be so
available, or (2) arrange to deprive yourself of the benefit of the
patent license for this particular work, or (3) arrange, in a manner
consistent with the requirements of this License, to extend the patent
license to downstream recipients. "Knowingly relying" means you have
actual knowledge that, but for the patent license, your conveying the
covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that
country that you have reason to believe are valid.
If, pursuant to or in connection with a single transaction or
arrangement, you convey, or propagate by procuring conveyance of, a
covered work, and grant a patent license to some of the parties
receiving the covered work authorizing them to use, propagate, modify
or convey a specific copy of the covered work, then the patent license
you grant is automatically extended to all recipients of the covered
work and works based on it.
A patent license is "discriminatory" if it does not include within
the scope of its coverage, prohibits the exercise of, or is
conditioned on the non-exercise of one or more of the rights that are
specifically granted under this License. You may not convey a covered
work if you are a party to an arrangement with a third party that is
in the business of distributing software, under which you make payment
to the third party based on the extent of your activity of conveying
the work, and under which the third party grants, to any of the
parties who would receive the covered work from you, a discriminatory
patent license (a) in connection with copies of the covered work
conveyed by you (or copies made from those copies), or (b) primarily
for and in connection with specific products or compilations that
contain the covered work, unless you entered into that arrangement,
or that patent license was granted, prior to 28 March 2007.
Nothing in this License shall be construed as excluding or limiting
any implied license or other defenses to infringement that may
otherwise be available to you under applicable patent law.
12. No Surrender of Others' Freedom.
If conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot convey a
covered work so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you may
not convey it at all. For example, if you agree to terms that obligate you
to collect a royalty for further conveying from those to whom you convey
the Program, the only way you could satisfy both those terms and this
License would be to refrain entirely from conveying the Program.
13. Use with the GNU Affero General Public License.
Notwithstanding any other provision of this License, you have
permission to link or combine any covered work with a work licensed
under version 3 of the GNU Affero General Public License into a single
combined work, and to convey the resulting work. The terms of this
License will continue to apply to the part which is the covered work,
but the special requirements of the GNU Affero General Public License,
section 13, concerning interaction through a network will apply to the
combination as such.
14. Revised Versions of this License.
The Free Software Foundation may publish revised and/or new versions of
the GNU General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the
Program specifies that a certain numbered version of the GNU General
Public License "or any later version" applies to it, you have the
option of following the terms and conditions either of that numbered
version or of any later version published by the Free Software
Foundation. If the Program does not specify a version number of the
GNU General Public License, you may choose any version ever published
by the Free Software Foundation.
If the Program specifies that a proxy can decide which future
versions of the GNU General Public License can be used, that proxy's
public statement of acceptance of a version permanently authorizes you
to choose that version for the Program.
Later license versions may give you additional or different
permissions. However, no additional obligations are imposed on any
author or copyright holder as a result of your choosing to follow a
later version.
15. Disclaimer of Warranty.
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. Limitation of Liability.
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGES.
17. Interpretation of Sections 15 and 16.
If the disclaimer of warranty and limitation of liability provided
above cannot be given local legal effect according to their terms,
reviewing courts shall apply local law that most closely approximates
an absolute waiver of all civil liability in connection with the
Program, unless a warranty or assumption of liability accompanies a
copy of the Program in return for a fee.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
state the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
<one line to give the program's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
Also add information on how to contact you by electronic and paper mail.
If the program does terminal interaction, make it output a short
notice like this when it starts in an interactive mode:
<program> Copyright (C) <year> <name of author>
This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, your program's commands
might be different; for a GUI interface, you would use an "about box".
You should also get your employer (if you work as a programmer) or school,
if any, to sign a "copyright disclaimer" for the program, if necessary.
For more information on this, and how to apply and follow the GNU GPL, see
<http://www.gnu.org/licenses/>.
The GNU General Public License does not permit incorporating your program
into proprietary programs. If your program is a subroutine library, you
may consider it more useful to permit linking proprietary applications with
the library. If this is what you want to do, use the GNU Lesser General
Public License instead of this License. But first, please read
<http://www.gnu.org/philosophy/why-not-lgpl.html>.
================================================
FILE: LICENSE.txt
================================================
The QP-nano Real-Time Embedded Framework (RTEF) is licensed under the
dual-licensing model, in which both the open source and traditional
closed source software distribution models are combined. For more
information, please see:
https://www.state-machine.com/licensing
****
NOTE: If your company has a policy forbidding open source in your
product, all QP frameworks can be licensed commercially, in which
case you don't use any open source license and you do not violate
your policy.
****
Contact Information:
====================
- https://www.state-machine.com
- mailto:info@state-machine.com
================================================
FILE: README.md
================================================
---------------------------------------------------------------------------
# What's New?
**NOTE:** QP-nano has been **discontinued** from active development
and support and is **not recommended** for new designs. This QP-nano
repository is preserved for the existing user base.
**LICENSING:** If you are interested in commercial licensing QP-nano,
please refer to section [QP-nano Licensing](#qp-nano-licensing).
**QM Tool Compatibility:** The last QM version that supports code
generation for QP-nano is
[QM 5.2.3 released on 2022-11-18](https://www.state-machine.com/qm/history.html#qm_5_2_3).
Newer QM versions no longer support QP-nano.
# Documentation
The offline HTML documentation for **this** particular version of QP-nano
is located in the folder html/. To view the offline documentation, open
the file html/index.html in your web browser.
The online HTML documention for the **latest** version of QP-nano is located
at: https://www.state-machine.com/qpn/
# About QP-nano
QP-nano (Quantum Platform Nano) is an ultra-lightweight, open source
[Real-Time Embedded Framework (RTEF)][RTEF] for building modern embedded
software as systems of asynchronous, event-driven [active objects][Active]
(actors). The [QP-nano] framework is a member of a larger [QP] family
consisting of [QP/C], [QP/C++], and [QP-nano] frameworks, which are all
strictly quality controlled, thoroughly documented, and [commercially
licensable][Lic].
## Safer Model of Concurrency
The [QP] framework family is based on the [Active Object][Active] (**actor**)
design pattern, which inherently supports and automatically enforces the
following best practices of concurrent programming:
- Keep data isolated and bound to active objects' threads. Threads should
hide (**encapsulate**) their private data and other resources, and not
share them with the rest of the system.
- Communicate among active object threads **asynchronously** via event
objects. Using asynchronous events keeps the threads running truly
independently, **without blocking** on each other.
- Active object threads should spend their lifetime responding to incoming
events, so their mainline should consist of an **event-loop** that handles
events one at a time (to completion), thus avoiding any concurrency hazards
within an active object thread itself.
This architecture is generally **safer**, more responsive and easier to
understand and maintain than the shared-state concurrency of a conventional
RTOS. It also provides higher level of abstraction and the *correct*
abstractions to effectively apply **modeling** and **code generation** to
deeply embedded real-time systems.
## Hierarchical State Machines
The behavior of active objects is specified in QP-nano by means of
[Hierarchical State Machines][HSM] (UML statecharts). The framework
supports manual coding of UML state machines in C as well as automatic
**code generation** by means of the free [QM modeling tool][QM].
## Built-in Real-Time Kernels
The QP-nano framework can run on bare-metal single-chip microcontrollers,
completely replacing a traditional "superloop" or an RTOS. The framework
contains a selection of **built-in real-time kernels**, such as the
cooperative QV-nano kernel and the preemptive non-blocking QK-nano kernel.
Native QP-nano ports and ready-to-use examples are provided for such CPUs
MSP430, AVRmega, and ARM Cortex-M (M0/M0+/M3/M4).
## Maturity
With 60,000 downloads a year, the [QP] family is the most popular such
solution on the embedded software market. It provides a modern, reusable
architecture for embedded applications, which combines the active-object
model of concurrency with hierarchical state machines.
# Getting Started with QP-nano
The [QP-nano Reference Manual](https://www.state-machine.com/qpn/) provides
instructions on how to download, install, and get started with QP-nano quickly.
The [AppNote: "Getting Started with QP-nano"][AN] contains also a tutorial,
in which you build a simple "Blinky" application.
# QP-nano Licensing
QP-nano is licensed under the
[dual licensing model](https://www.state-machine.com/licensing),
in which both the open source software distribution mechanism and
traditional closed source software distribution models are combined.
> **NOTE:** Even though QP-nano has been discontinued, Quantum Leaps will
continue to provide commercial licenses for QP-nano to customers still
interested in deploying QP-nano in closed-source products. These commercial
licenses will NOT provide technical support and will be discounted accordingly.
# QP-nano Documentation
The **QP-nano Manual** is located online at: https://www.state-machine.com/qpn
# 3rd-Party QP-nano Ports/Adaptations
[<b>QPN-PIC16</b>](https://github.com/aschatte/qpn) is an adaptation of the
QP-nano framework to the
[Microchip PIC16](https://www.microchip.com/en-us/products/microcontrollers-and-microprocessors/8-bit-mcus/pic-mcus)
architecture as compiled by the MPALB-X IDE using the XC8 compiler (C90/C99).
It allows QP-nano models developed using the QM modeling tool to be integrated
with the QV-nano kernel to build
[Active Object](https://www.state-machine.com/active-object) applications.
The very limited resources of the PIC16 family of MCUs, primarily the hardware
stack, required a special version of QP-nano and a QM-Modeler editing
post-processor, `QM2HSM.exe`, to effect.
# How to get help?
- [Free Support Forum](https://sourceforge.net/p/qpc/discussion/668726)
- [Bug Reports](https://sourceforge.net/p/qpc/bugs/)
- [Feature Requests](https://sourceforge.net/p/qpc/feature-requests/)
- [Quantum Leaps website](https://www.state-machine.com)
- [Quantum Leaps licensing](https://www.state-machine.com/licensing)
- [info@state-machine.com](mailto:info@state-machine.com)
[RTEF]: <https://www.state-machine.com/doc/concepts#RTEF>
[QP]: <https://www.state-machine.com/products/#QP>
[QP/C]: <https://www.state-machine.com/qpc>
[QP/C++]: <https://www.state-machine.com/qpcpp>
[QP-nano]: <https://www.state-machine.com/qpn>
[QM]: <https://www.state-machine.com/qm>
[Active]: <https://www.state-machine.com/doc/concepts#Active>
[HSM]: <https://www.state-machine.com/doc/concepts#HSM>
[Lic]: <https://www.state-machine.com/licensing>
[AN]: <https://www.state-machine.com/doc/AN_Getting_Started_with_QP-nano.pdf>
================================================
FILE: doxygen/Doxyfile
================================================
# Doxyfile 1.9.4
@INCLUDE = ../../ql-doxygen/ql-doxyfile
#---------------------------------------------------------------------------
# Project related configuration options
#---------------------------------------------------------------------------
DOXYFILE_ENCODING = UTF-8
PROJECT_NAME = "QP-nano"
PROJECT_NUMBER = "6.9.0"
PROJECT_BRIEF = "Real-Time Embedded Framework"
PROJECT_LOGO = ../../ql-doxygen/images/logo_ql.png
OUTPUT_DIRECTORY =
CREATE_SUBDIRS = NO
CREATE_SUBDIRS_LEVEL = 6
ALLOW_UNICODE_NAMES = NO
OUTPUT_LANGUAGE = English
BRIEF_MEMBER_DESC = YES
REPEAT_BRIEF = NO
ABBREVIATE_BRIEF = "The $name class" \
"The $name widget" \
"The $name file" \
is \
provides \
specifies \
contains \
represents \
a \
an \
the
ALWAYS_DETAILED_SEC = NO
INLINE_INHERITED_MEMB = NO
FULL_PATH_NAMES = NO
STRIP_FROM_PATH =
STRIP_FROM_INC_PATH =
SHORT_NAMES = NO
JAVADOC_AUTOBRIEF = YES
JAVADOC_BANNER = NO
QT_AUTOBRIEF = NO
MULTILINE_CPP_IS_BRIEF = NO
PYTHON_DOCSTRING = YES
INHERIT_DOCS = YES
SEPARATE_MEMBER_PAGES = NO
TAB_SIZE = 4
OPTIMIZE_OUTPUT_FOR_C = YES
OPTIMIZE_OUTPUT_JAVA = NO
OPTIMIZE_FOR_FORTRAN = NO
OPTIMIZE_OUTPUT_VHDL = NO
OPTIMIZE_OUTPUT_SLICE = NO
EXTENSION_MAPPING = lnt=Objective-C
MARKDOWN_SUPPORT = YES
TOC_INCLUDE_HEADINGS = 4
AUTOLINK_SUPPORT = YES
BUILTIN_STL_SUPPORT = NO
CPP_CLI_SUPPORT = NO
SIP_SUPPORT = NO
IDL_PROPERTY_SUPPORT = YES
DISTRIBUTE_GROUP_DOC = NO
GROUP_NESTED_COMPOUNDS = NO
SUBGROUPING = YES
INLINE_GROUPED_CLASSES = YES
INLINE_SIMPLE_STRUCTS = YES
TYPEDEF_HIDES_STRUCT = YES
LOOKUP_CACHE_SIZE = 0
NUM_PROC_THREADS = 1
#---------------------------------------------------------------------------
# Build related configuration options
#---------------------------------------------------------------------------
EXTRACT_ALL = YES
EXTRACT_PRIVATE = YES
EXTRACT_PRIV_VIRTUAL = NO
EXTRACT_PACKAGE = YES
EXTRACT_STATIC = YES
EXTRACT_LOCAL_CLASSES = YES
EXTRACT_LOCAL_METHODS = NO
EXTRACT_ANON_NSPACES = NO
RESOLVE_UNNAMED_PARAMS = YES
HIDE_UNDOC_MEMBERS = NO
HIDE_UNDOC_CLASSES = NO
HIDE_FRIEND_COMPOUNDS = NO
HIDE_IN_BODY_DOCS = NO
INTERNAL_DOCS = NO
CASE_SENSE_NAMES = NO
HIDE_SCOPE_NAMES = YES
HIDE_COMPOUND_REFERENCE= NO
SHOW_HEADERFILE = YES
SHOW_INCLUDE_FILES = YES
SHOW_GROUPED_MEMB_INC = NO
FORCE_LOCAL_INCLUDES = NO
INLINE_INFO = YES
SORT_MEMBER_DOCS = NO
SORT_BRIEF_DOCS = NO
SORT_MEMBERS_CTORS_1ST = NO
SORT_GROUP_NAMES = NO
SORT_BY_SCOPE_NAME = NO
STRICT_PROTO_MATCHING = NO
GENERATE_TODOLIST = YES
GENERATE_TESTLIST = YES
GENERATE_BUGLIST = YES
GENERATE_DEPRECATEDLIST= YES
ENABLED_SECTIONS = QPN
MAX_INITIALIZER_LINES = 30
SHOW_USED_FILES = YES
SHOW_FILES = YES
SHOW_NAMESPACES = YES
FILE_VERSION_FILTER =
LAYOUT_FILE =
CITE_BIB_FILES =
#---------------------------------------------------------------------------
# Configuration options related to warning and progress messages
#---------------------------------------------------------------------------
QUIET = NO
WARNINGS = YES
WARN_IF_UNDOCUMENTED = YES
WARN_IF_DOC_ERROR = YES
WARN_IF_INCOMPLETE_DOC = YES
WARN_NO_PARAMDOC = NO
WARN_AS_ERROR = NO
WARN_FORMAT = "$file:$line: $text"
WARN_LINE_FORMAT = "at line $line of file $file"
WARN_LOGFILE =
#---------------------------------------------------------------------------
# Configuration options related to the input files
#---------------------------------------------------------------------------
INPUT = main.dox \
gs.dox \
struct.dox \
api.dox \
exa.dox \
exa_apps.dox \
exa_native.dox \
exa_os.dox \
ports.dox \
ports_native.dox \
ports_arm-cm.dox \
ports_os.dox \
history.dox \
macros.h \
../../ql-doxygen/help.dox \
metrics.dox \
modules.dox \
../include \
../src
INPUT_ENCODING = UTF-8
FILE_PATTERNS = *.dox \
*.h \
*.hpp \
*.c \
*.cpp \
*.s \
*.asm \
*.lnt
RECURSIVE = YES
EXCLUDE =
EXCLUDE_SYMLINKS = NO
EXCLUDE_PATTERNS =
EXCLUDE_SYMBOLS = QP_IMPL
EXAMPLE_PATH = snippets \
../include \
../src \
../ports \
../examples
EXAMPLE_PATTERNS = *
EXAMPLE_RECURSIVE = NO
IMAGE_PATH = images \
../../ql-doxygen/images
INPUT_FILTER =
FILTER_PATTERNS =
FILTER_SOURCE_FILES = NO
FILTER_SOURCE_PATTERNS =
USE_MDFILE_AS_MAINPAGE =
#---------------------------------------------------------------------------
# Configuration options related to source browsing
#---------------------------------------------------------------------------
SOURCE_BROWSER = YES
INLINE_SOURCES = NO
STRIP_CODE_COMMENTS = YES
REFERENCED_BY_RELATION = NO
REFERENCES_RELATION = NO
REFERENCES_LINK_SOURCE = YES
SOURCE_TOOLTIPS = YES
USE_HTAGS = NO
VERBATIM_HEADERS = YES
CLANG_ASSISTED_PARSING = NO
CLANG_ADD_INC_PATHS = YES
CLANG_OPTIONS =
CLANG_DATABASE_PATH =
#---------------------------------------------------------------------------
# Configuration options related to the alphabetical class index
#---------------------------------------------------------------------------
ALPHABETICAL_INDEX = YES
IGNORE_PREFIX =
#---------------------------------------------------------------------------
# Configuration options related to the HTML output
#---------------------------------------------------------------------------
GENERATE_HTML = YES
HTML_OUTPUT = ../html
HTML_FILE_EXTENSION = .html
HTML_HEADER = ../../ql-doxygen/ql-header-awesome.html
HTML_FOOTER = ../../ql-doxygen/ql-footer-awesome.html
HTML_STYLESHEET =
HTML_EXTRA_STYLESHEET = ../../ql-doxygen/doxygen-awesome.css \
../../ql-doxygen/doxygen-awesome-sidebar-only.css \
../../ql-doxygen/doxygen-awesome-sidebar-only-darkmode-toggle.css \
../../ql-doxygen/ql-awesome.css
HTML_EXTRA_FILES = ../../ql-doxygen/doxygen-awesome-darkmode-toggle.js \
../../ql-doxygen/doxygen-awesome-fragment-copy-button.js \
../../ql-doxygen/doxygen-awesome-paragraph-link.js \
../../ql-doxygen/ql-preview.js
HTML_COLORSTYLE_HUE = 209
HTML_COLORSTYLE_SAT = 255
HTML_COLORSTYLE_GAMMA = 113
HTML_TIMESTAMP = NO
HTML_DYNAMIC_MENUS = YES
HTML_DYNAMIC_SECTIONS = NO
HTML_INDEX_NUM_ENTRIES = 100
GENERATE_DOCSET = NO
DOCSET_FEEDNAME = "Doxygen generated docs"
DOCSET_FEEDURL =
DOCSET_BUNDLE_ID = com.state-machine.doc
DOCSET_PUBLISHER_ID = com.state-machine.doc
DOCSET_PUBLISHER_NAME = QuantumLeaps
GENERATE_HTMLHELP = NO
CHM_FILE = ../qpn.chm
HHC_LOCATION =
GENERATE_CHI = NO
CHM_INDEX_ENCODING =
BINARY_TOC = YES
TOC_EXPAND = NO
GENERATE_QHP = NO
QCH_FILE =
QHP_NAMESPACE = com.state-machine.qp
QHP_VIRTUAL_FOLDER = doc
QHP_CUST_FILTER_NAME =
QHP_CUST_FILTER_ATTRS =
QHP_SECT_FILTER_ATTRS =
QHG_LOCATION =
GENERATE_ECLIPSEHELP = NO
ECLIPSE_DOC_ID = com.state-machine.qp
DISABLE_INDEX = NO
GENERATE_TREEVIEW = YES
FULL_SIDEBAR = NO
ENUM_VALUES_PER_LINE = 4
TREEVIEW_WIDTH = 335
EXT_LINKS_IN_WINDOW = NO
OBFUSCATE_EMAILS = NO
HTML_FORMULA_FORMAT = png
FORMULA_FONTSIZE = 10
FORMULA_TRANSPARENT = YES
FORMULA_MACROFILE =
USE_MATHJAX = NO
MATHJAX_VERSION = MathJax_2
MATHJAX_FORMAT = HTML-CSS
MATHJAX_RELPATH = https://cdn.jsdelivr.net/npm/mathjax@2
MATHJAX_EXTENSIONS =
MATHJAX_CODEFILE =
SEARCHENGINE = YES
SERVER_BASED_SEARCH = NO
EXTERNAL_SEARCH = NO
SEARCHENGINE_URL =
SEARCHDATA_FILE = searchdata.xml
EXTERNAL_SEARCH_ID = QPN
EXTRA_SEARCH_MAPPINGS =
#---------------------------------------------------------------------------
# Configuration options related to the preprocessor
#---------------------------------------------------------------------------
ENABLE_PREPROCESSING = YES
MACRO_EXPANSION = NO
EXPAND_ONLY_PREDEF = NO
SEARCH_INCLUDES = YES
INCLUDE_PATH =
INCLUDE_FILE_PATTERNS =
PREDEFINED = Q_PARAM_SIZE=2 \
QF_TIMEEVT_CTR_SIZE=2 \
QF_TIMEEVT_PERIODIC \
QF_TIMEEVT_USAGE \
QK_SCHED_LOCK \
QK_ON_CONTEXT_SW
EXPAND_AS_DEFINED =
SKIP_FUNCTION_MACROS = YES
================================================
FILE: doxygen/Doxyfile-CHM
================================================
# Doxyfile 1.9.2
@INCLUDE = Doxyfile
#---------------------------------------------------------------------------
# Configuration options related to the HTML output
#---------------------------------------------------------------------------
HTML_OUTPUT = tmp
HTML_HEADER = ../../ql-doxygen/header.html
HTML_FOOTER = ../../ql-doxygen/footer.html
HTML_EXTRA_STYLESHEET = ../../ql-doxygen/ql.css \
../../ql-doxygen/preview.js
HTML_EXTRA_FILES =
GENERATE_HTMLHELP = YES
================================================
FILE: doxygen/api.dox
================================================
/*! @page api API Reference
@tableofcontents
@section api_qepn QEP-nano (Hierarchical State Machines)
QEP is a universal, UML-compliant event processor that enables developers to code UML state machines in highly readable ANSI-C, in which every state machine element is mapped to code precisely, unambiguously, and exactly once (traceability). QEP fully supports hierarchical state nesting, which is the fundamental mechanism for reusing behavior across many states instead of repeating the same actions and transitions over and over again.
@subsection api_qep_hsm Hierarchical State Machines
- ::QHsm class
- QHsm_ctor()
- QHSM_INIT()
- QHSM_DISPATCH()
- QHsm_state()
- QHsm_top()
@section api_qfn QF-nano (Active Object Framework)
QF is a portable, event-driven, real-time framework for execution of active objects (concurrent state machines) specifically designed for real-time embedded (RTE) systems.
@subsection api_qfn_act Active Objects
- ::QActive class
- QActive_ctor()
- QACTIVE_POST()
- QACTIVE_POST_X()
@subsection api_qfn_time Time Events
- QF_tickXISR()
- QActive_armX()
- QActive_disarmX()
@section api_qvn QV-nano (Cooperative Kernel)
QV is a simple **cooperative** kernel (previously called "Vanilla" kernel). This kernel executes active objects one at a time, with priority-based scheduling performed before processing of each event. Due to naturally short duration of event processing in state machines, the simple QV kernel is often adequate for many real-time systems.
The QV scheduler is engaged after every RTC step of any @termref{active object} to choose the next active object to execute. The QV scheduler always chooses the highest-priority active object that has any events in its event queue. The QV scheduler then extracts the next event from this queue and dispatches it to the state machine associated with the active object. The state machine runs to completion, after which the QV scheduler runs and the cycle repeats.
Please note that because the state machines always return to the QV scheduler after each RTC step, a single stack can be used to process all state machines (memory-friendly architecture).
The QV scheduler can also very easily detect when all event queues are empty, at which point it can call the idle callback to let the application put the CPU and peripherals to a low-power sleep mode (power-friendly architecture).
Given the simplicity, portability, and low-resource consumption, the QV scheduler is very attractive. It allows you to partition the problem into active objects and execute these active objects orderly. The task-level response of this scheduler is the longest RTC step in the whole system, but because event-driven active objects don’t block, the RTC steps tend to be very short (typically just a few microseconds). Also, often you can break up longer RTC steps into shorter pieces, by posting an event to self and returning (“Reminder” state pattern). The self-posted event then triggers the continuation of longer processing.
@subsection api_qv_init Kernel Initialization and Control
- QV_INIT()
- <a href="qv_8c.html#a779a1bc9482e2d489dc87751cd100fdb"><b>QF_run()</b></a>
- QV_onIdle()
- QV_CPU_SLEEP()
@section api_qkn QK-nano (Preemptive Run-to-Completion Kernel)
QK is a tiny **preemptive**, priority-based, non-blocking kernel designed specifically for executing active objects. QK runs active objects in the same way as prioritized interrupt controller (such as NVIC in ARM Cortex-M) runs interrupts using the single stack. Active objects process their events in run-to-completion (RTC) fashion and remove themselves from the call stack, the same way as nested interrupts remove themselves from the stack upon completion. At the same time high-priority active objects can preempt lower-priority active objects, just like interrupts can preempt each other under a prioritized interrupt controller. QK meets all the requirement of the Rate Monotonic Scheduling (a.k.a. Rate Monotonic Analysis RMA) and can be used in hard real-time systems.
@subsection api_qkn_ctrl Kernel Initialization and Control
- QK_INIT()
- <a href="qk_8c.html#a779a1bc9482e2d489dc87751cd100fdb"><b>QF_run()</b></a>
- QK_onIdle()
- QK_schedLock()
- QK_schedUnlock()
@subsection api_qkn_isr Interrupt Management
- QK_ISR_ENTRY()
- QK_ISR_EXIT()
*/
================================================
FILE: doxygen/exa.dox
================================================
/*! @page exa Examples
@tableofcontents
@section exa_gen General Comments
The QP-nano distribution contains many @subpage exa_ref "example projects" to demonstrate various QP-nano features. Each example project is described on its own dedicated page that you can find using several criteria (see @ref exa_ref). The example projects have the following main goals:
- **to help you learn how to use QP-nano** — the examples show the intended way of using QP-nano features and structuring QP-nano applications.
- **to provide you with a starting point for your own projects** — the examples are complete working projects, with correctly pre-configured tools, such as compiler options, linker script, debugger setup, etc.
@note
It is highly recommended that you create your own projects by **copying and modifying** existing example projects rather than starting your QP-nano projects from scratch.
@subsection exa_code Example Code Structure
Starting with QP-nano release 5.4.0, **all** examples are bundled into the QP-nano download, as opposed to being distributed as separate QP Development Kits (QDKs). The main benefit is of this approach is that it greatly reduces chances of mistakes in combining the mainline QP-nano code with various QDKs. The downside is that the QP-nano distribution becomes quite large and that examples can't be added or updated independently from the QP-nano baseline code.
All examples are located in sub-directories of the <span class="img folder">examples</span> @ref qpn_files "top-level folder", with the hierarchical organization outlined below:
<ul class="tag">
<li><span class="img folder">examples</span>
</li>
<ul class="tag">
<li><span class="img folder">arm-cm</span> — Native examples for ARM-Cortex-M (bare-metal) [A]
</li>
<ul class="tag">
<li><span class="img folder">blinky_ek-tm4c123gxl</span> — Blinky example for EK-TM4C123GXL board
</li>
<ul class="tag">
<li><span class="img folder">qk</span> — Version for the @ref comp_qk "preemptive QK kernel"
</li>
<ul class="tag">
<li><span class="img folder">arm</span> — build with ARM toolset
</li>
<ul class="tag">
<li><span class="img folder">dbg</span> — Debug @ref exa_sec_conf "build configuration"
</li>
<li><span class="img folder">rel</span> — Release build configuration
</li>
</ul>
<li><span class="img folder">gnu</span> — build with GNU toolset
</li>
<li><span class="img folder">iar</span> — build with IAR toolset
</li>
</ul>
<li><span class="img folder">qv</span> — Version for the @ref comp_qv "cooperative QV kernel"
</li>
<ul class="tag">
<li><span class="img folder">arm</span> — build with ARM toolset
</li>
<ul class="tag">
<li><span class="img folder">dbg</span> — Debug @ref exa_sec_conf "build configuration"
</li>
<li><span class="img folder">rel</span> — Release build configuration
</li>
</ul>
<li><span class="img folder">gnu</span> — build with GNU toolset
</li>
<li><span class="img folder">iar</span> — build with IAR toolset
</li>
</ul>
<li><span class="img file_c">...</span> — source code independent on the toolset
</li>
</ul>
</ul>
<li><span class="img folder">workstation</span> — Examples for Workstations [B]
</li>
<ul class="tag">
<li><span class="img folder">blinky</span> — Blinky example for workstations (console app)</li>
<li><span class="img folder">dpp</span> — DPP example for workstations (console app)</li>
<li><span class="img folder">. . .</span> — Other examples for workstations (console app)</li>
</ul>
</ul>
</ul>
<ul class="tag">
<li><span class="tag">A</span> @subpage exa_native "Native examples" are located in sub-directories named after the CPU architecture, such as <span class="img folder">arm-cm</span> for ARM Cortex-M. Under that directory, the sub-directories <span class="img folder">blinky_ek-tm4c123gxl</span> contain the specific example on the specified board, such as "Blinky" on the EK-TM4C123GXL board here. In the specific example folder, you find sub-folders for the @ref comp_qk "QK" and @ref comp_qv "QV" kernels, respectively.
</li>
<li><span class="tag">B</span> @subpage exa_os "Examples for Workstations" are located in sub-directory <span class="img folder">workstation</span>. These examples can be built on Windows, Linux and MacOS.
</li>
</ul>
@note
Because the QP-nano distribution contains *all* examples, the number of sub-directories and files in the <span class="img folder">examples</span> folder may seem daunting. However, knowing the structure of the <span class="img folder">examples</span> folder, you can simply **delete** the sub-directories that are not interesting to you.
@subsection exa_sec_apps Example Applications
To demonstrate QP-nano features on an embedded board, you need to create an application that does "something interesting". Instead of inventing this "something interesting" for each and every example, the example projects implement one of the three @subpage exa_apps "example applications", which are described on the separate pages:
- @ref blinky
- @ref dpp
- @ref pelican
- @ref game
With the exception of the game application, all other example applications can be implemented on a board with just a couple of LEDs. The @ref game application is a bit more involved and requires a small graphic display on the board.
Beyond these basic applications for demonstrating and testing the various @ref ports "QP-nano ports", the QP-nano distribution contains all examples described in the book <a class="extern" target="_blank" href="https://www.state-machine.com/psicc2" >Practical UML Statecharts in C/C++, 2nd Edition</a>
@sa
@ref exa_os
@subsection exa_sec_boards Development Boards
While some provided examples can run on your @ref exa_os "desktop computer", most embedded example projects require special hardware in form of @ref exa_sec_boards, which you need to acquire to be able to run the examples. The boards chosen for the examples are generally inexpensive and self-contained with no need for external hardware (such as external JTAG debuggers or power supplies).
@subsection exa_sec_tools Development Tools
Most provided examples require special embedded cross-development tools, such as embedded compilers, linkers, debuggers and IDEs, which you need to acquire independently from the QP-nano distribution. Generally, the examples work with the free (size limited) evaluation versions of the commercial tools. The examples list the versions of tools they were developed and tested with. Please refer to the @ref exa_ref "cross-reference section" @ref exa_sec_tools to see which embedded toolsets are used.
@subsection exa_sec_conf Build Configurations
QP examples @ref ports "QP ports" are provided in the following three **build configurations**:
- **Debug** — this configuration is built with full debugging information and minimal optimization. When the QP framework finds no events to process, the framework busy-idles until there are new events to process.
- **Release** — this configuration is built with no debugging information and high optimization. Single-stepping and debugging at the source-code level is effectively impossible due to the lack of debugging information and optimized code, but the debugger can be used to download and start the executable. When the QP framework finds no events to process, the framework puts the CPU to sleep until there are new events to process.
@remark
<strong>Why do you need multiple build configurations?</strong>@n
The different phases of embedded software life cycle pose different challenges. During the development and maintenance phase, for example, the emphasis is on the ease of debugging and verifying the correctness of the code, which require lower levels of optimization and special scaffolding code. In contrast, for releasing the code in the final product, the emphasis is on small memory footprint and CPU time efficiency, which require high-level of optimization and removal of any scaffolding code. To address these conflicting needs, the same source code is compiled into multiple **build configurations** that differ in the use of compiler options and activation of the scaffolding code.
@subsection exa_sec_qm QM Models
Many example projects contain code auto-generated by the <a class="extern" target="_blank" href="https://www.state-machine.com/qm/help"><strong>QM modeling tool</strong></a>. Such projects always contain the corresponding **QM model** file, which you can open in QM, modify, and re-generate the code.
@note
The auto-generated files are saved as **read-only**. This protects them from inadvertent modifications, which will get lost when the files are re-generated by QM (or QMC). All modifications to the auto-generated code should be done in the QM model, not in the code.
@subsection exa_sec_3rd Third-Party Code
The QP-nano example projects often need to use various additional code, such as MCU register definition files, startup code, device drivers, etc., which are provided by Third-Party vendors. All such code is located in the <span class="img folder">3rd_party</span> @ref qpn_files "top-level folder".
@note
As far as possible, the code in the <span class="img folder">3rd_party</span> folder has been left unchanged from the original source. (Any modified code is clearly identified by top-level comments that detail the applied changes.) For that reason, the Third-Party code might produce **compilation warnings** in your builds.
The code in the <span class="img folder">3rd_party</span> folder comes from various sources, and Quantum
Leaps, LLC expressly makes **no claims of ownership** to any of this code, even though some of the code might be customized or modified by Quantum Leaps.
@attention
The Third-Party software components included in the <span class="img folder">3rd_party</span> folder are licensed under a variety of different licensing terms that are defined by the respective owners of this software and are spelled out in the `README.txt` or `LICENSE.txt` files included in the respective
sub-folders.
@section exa_own Creating your Own QP-nano Projects
Perhaps the most important fact of life to remember is that in embedded systems nothing works until everything works. This means that you should always start with a <strong>working system</strong> and gradually evolve it, changing one thing at a time and making sure that it keeps working every step of the way.
Keeping this in mind, the provided QP-nano application examples, such as the super-simple Blinky, or a bit more advanced @ref dpp or @ref game, allow you to get started with a working project rather than starting from scratch. You should also always try one of the provided example projects on the same evaluation board that it was designed for, before making any changes.
Only after convincing yourself that the example project works "as is", you can think about creating your own projects. At this point, the easiest and recommended way is to copy the existing working example project folder (such as the Blinky example) and rename it.
After copying the project folder, you still need to change the name of the project/workspace. The easiest and safest way to do this is to open the project/workspace in the corresponding IDE and use the Save As... option to save the project under a different name. You can do this also with the QM model file, which you can open in QM and "Save As" a different model.
@note
By copying and re-naming an existing, working project, as opposed to creating a new one from scratch, you inherit the correct compiler and linker options an other project settings, which will help you get started much faster.
@section exa_doc Next Steps and Further Reading About QP and QM
To work with QP-nano effectively, you need to learn a bit more about active objects and state machines. Below is a list of links to enable you to further your knowledge:
1. The book “Practical UML Statecharts in C/C++, 2nd Edition” [PSiCC2] and the companion web-page to the book (https://www.state-machine.com/psicc2/
2. Free Support Forum for QP/QM (https://sourceforge.net/p/qpc/discussion/668726 )
3. QP Code Downloads summary (https://www.state-machine.com/downloads )
4. QP Application Notes (https://www.state-machine.com/doc/an )
5. "State Space" Blog (http://embeddedgurus.com/state-space/ )
@next{exa_ref}
*/
/*##########################################################################*/
/*! @page exa_ref Cross-Reference
@tableofcontents
@section exa_ref_native Native Examples (by Built-in Kernel)
- @ref exa_qv
- @ref exa_qk
@section exa_ref_native Native Examples (by Processor)
- @ref exa_arm-cm (Cortex-M0/M0+/M3/M4/M4F)
- @ref exa_arm7-9 ("classic ARM")
- @ref exa_msp430 ("classic" MSP430 and "extended" MSP430x)
- @ref exa_avr (8-bit megaAVR)
@section exa_ref_os Examples for Third-Party OS
- @subpage exa_os
@section exa_ref_boards Examples by Development Board
The boards chosen for the examples are generally inexpensive and self-contained with minimal need for external hardware (such as external JTAG debuggers or power supplies). Also, all the selected boards provide a virtual COM port (ideally).
@note
You can hover the mouse cursor over the <span class="board"></span> icon in the list below to see the picture of the board.
- ARM Cortex-M Boards:
- <a class="preview board" href="bd_EK-TM4C123GXL.jpg" title="EK-TM4C123GXL">EK-TM4C123GXL</a> (TivaC LaunchPad)
- <a class="preview board" href="bd_EFM32-SLSTK3401A.jpg" title="EFM32-SLSTK3401A">EFM32-SLSTK3401A</a>
- <a class="preview board" href="bd_mbed-LPC1768.jpg" title="mbed-LPC1768">mbed-LPC1768</a>
- <a class="preview board" href="bd_nucleo-l053r8.jpg" title="NUCLEO-L053R8">NUCLEO-L053R8</a>
- <a class="preview board" href="bd_nucleo-l152re.jpg" title="NUCLEO-L152RE">NUCLEO-L152RE</a>
- <a class="preview board" href="bd_EK-LM3S6965.jpg" title="EK-LM3S6965">EK-LM3S6965</a>
- <a class="preview board" href="bd_STM32F4-Discovery.jpg" title="STM32F4-Discovery">STM32F4-Discovery</a>
- ARM7 Boards:
- <a class="preview board" href="bd_AT91SAM7S-EK.jpg" title="AT91SAM7S-EK">AT91SAM7S-EK</a>
- MSP430 Boards:
- <a class="preview board" href="bd_MSP-EXP430G2.jpg" title="MSP-EXP430G2">MSP-EXP430G2</a> (MSP430 LaunchPad)
- <a class="preview board" href="bd_MSP-EXP430F5529LP.jpg" title="MSP-EXP430F5529LP">MSP-EXP430F5529LP</a> (MSP430X LaunchPad)
- AVR (megaAVR) Boards:
- <a class="preview board" href="bd_Arduino-UNO.jpg" title="Arduino-UNO">Arduino-UNO</a>
@section exa_ref_mcu Native Examples by MCU Architecture
- ARM Cortex-M0/M0+
- @ref arm-cm_dpp_nucleo-l053r8 <a class="preview board" href="bd_nucleo-l053r8.jpg" title="NUCLEO-L053R8"></a>
- ARM Cortex-M3
- @ref arm-cm_dpp_nucleo-l152re <a class="preview board" href="bd_nucleo-l152re.jpg" title="NUCLEO-L152RE"></a>
- @ref arm-cm_dpp_mbed-lpc1768 <a class="preview board" href="bd_mbed-LPC1768.jpg" title="mbed-LPC1768"></a>
- ARM Cortex-M4F (with hardware FPU)
- @ref arm-cm_blinky_ek-tm4c123gxl <a class="preview board" href="bd_EK-TM4C123GXL.jpg" title="EK-TM4C123GXL"></a>
- @ref arm-cm_blinky_efm32-slstk3401a <a class="preview board" href="bd_EFM32-SLSTK3401A.jpg" title="EFM32-SLSTK3401A"></a>
- @ref arm-cm_dpp_ek-tm4c123gxl <a class="preview board" href="bd_EK-TM4C123GXL.jpg" title="EK-TM4C123GXL"></a>
- @ref arm-cm_dpp_efm32-slstk3401a <a class="preview board" href="bd_EFM32-SLSTK3401A.jpg" title="EFM32-SLSTK3401A"></a>
- @ref arm-cm_game_efm32-slstk3401a <a class="preview board" href="bd_EFM32-SLSTK3401A.jpg" title="EFM32-SLSTK3401A"></a>
- ARM7 / ARM9
- @ref arm7-9_dpp_at91sam7s-ek <a class="preview board" href="bd_AT91SAM7S-EK.jpg" title="AT91SAM7S-EK"></a>
- MSP430
- @ref msp430_blinky_msp-exp430g2 <a class="preview board" href="bd_MSP-EXP430G2.jpg" title="MSP-EXP430G2"></a>
- @ref msp430_blinky_msp-exp430f5529lp <a class="preview board" href="bd_MSP-EXP430F5529LP.jpg" title="MSP-EXP430F5529LP"></a>
- @ref msp430_dpp_msp-exp430g2 <a class="preview board" href="bd_MSP-EXP430G2.jpg" title="MSP-EXP430G2"></a>
- AVRmega
- @ref avr_blinky_arduino-uno <a class="preview board" href="bd_Arduino-UNO.jpg" title="Arduino-UNO"></a>
- @ref avr_dpp_arduino-uno <a class="preview board" href="bd_Arduino-UNO.jpg" title="Arduino-UNO"></a>
- PIC24 /dsPIC (coming soon...)
- PIC32 (coming soon...)
- Renesas RX (coming soon...)
- TI TMS320C28x (C28x) (coming soon...)
- TI TMS320C55x (C55x) (coming soon...)
@section exa_ref_tool Native Examples by Development Toolchain
@n
@subsection exa_ref_arm-clang ARM-Clang Toolchain (ARM Compiler 6)
- @ref arm-cm_dpp_nucleo-l053r8 <a class="preview board" href="bd_nucleo-l053r8.jpg" title="NUCLEO-L053R8"></a>
- @ref arm-cm_dpp_ek-tm4c123gxl <a class="preview board" href="bd_EK-TM4C123GXL.jpg" title="EK-TM4C123GXL"></a>
@subsection exa_ref_arm-keil ARM-Keil Toolchain (ARM Compiler 5)
- @ref arm-cm_blinky_ek-tm4c123gxl <a class="preview board" href="bd_EK-TM4C123GXL.jpg" title="EK-TM4C123GXL"></a>
- @ref arm-cm_blinky_efm32-slstk3401a <a class="preview board" href="bd_EFM32-SLSTK3401A.jpg" title="EFM32-SLSTK3401A"></a>
- @ref arm-cm_dpp_ek-tm4c123gxl <a class="preview board" href="bd_EK-TM4C123GXL.jpg" title="EK-TM4C123GXL"></a>
- @ref arm-cm_dpp_efm32-slstk3401a <a class="preview board" href="bd_EFM32-SLSTK3401A.jpg" title="EFM32-SLSTK3401A"></a>
- @ref arm-cm_dpp_nucleo-l053r8 <a class="preview board" href="bd_nucleo-l053r8.jpg" title="NUCLEO-L053R8"></a>
- @ref arm-cm_dpp_nucleo-l152re <a class="preview board" href="bd_nucleo-l152re.jpg" title="NUCLEO-L152RE"></a>
- @ref arm-cm_game_efm32-slstk3401a <a class="preview board" href="bd_EFM32-SLSTK3401A.jpg" title="EFM32-SLSTK3401A"></a>
@subsection exa_ref_gnu-arm GNU-ARM (command-line with Makefile, importable to Eclipse)
- @ref arm-cm_blinky_ek-tm4c123gxl <a class="preview board" href="bd_EK-TM4C123GXL.jpg" title="EK-TM4C123GXL"></a>
- @ref arm-cm_blinky_efm32-slstk3401a <a class="preview board" href="bd_EFM32-SLSTK3401A.jpg" title="EFM32-SLSTK3401A"></a>
- @ref arm-cm_dpp_ek-tm4c123gxl <a class="preview board" href="bd_EK-TM4C123GXL.jpg" title="EK-TM4C123GXL"></a>
- @ref arm-cm_dpp_efm32-slstk3401a <a class="preview board" href="bd_EFM32-SLSTK3401A.jpg" title="EFM32-SLSTK3401A"></a>
- @ref arm-cm_dpp_mbed-lpc1768 <a class="preview board" href="bd_mbed-LPC1768.jpg" title="mbed-LPC1768"></a>
- @ref arm-cm_dpp_nucleo-l053r8 <a class="preview board" href="bd_nucleo-l053r8.jpg" title="NUCLEO-L053R8"></a>
- @ref arm-cm_dpp_nucleo-l152re <a class="preview board" href="bd_nucleo-l152re.jpg" title="NUCLEO-L152RE"></a>
- @ref arm-cm_game_efm32-slstk3401a <a class="preview board" href="bd_EFM32-SLSTK3401A.jpg" title="EFM32-SLSTK3401A"></a>
- @ref arm7-9_dpp_at91sam7s-ek <a class="preview board" href="bd_AT91SAM7S-EK.jpg" title="AT91SAM7S-EK"></a>
@subsection exa_ref_gnu-ccs GNU-ARM with TI CCS IDE
- @ref arm-cm_dpp_ek-tm4c123gxl <a class="preview board" href="bd_EK-TM4C123GXL.jpg" title="EK-TM4C123GXL"></a>
@subsection exa_ref_iar-arm IAR EWARM
- @ref arm-cm_blinky_ek-tm4c123gxl <a class="preview board" href="bd_EK-TM4C123GXL.jpg" title="EK-TM4C123GXL"></a>
- @ref arm-cm_blinky_efm32-slstk3401a <a class="preview board" href="bd_EFM32-SLSTK3401A.jpg" title="EFM32-SLSTK3401A"></a>
- @ref arm-cm_dpp_ek-tm4c123gxl <a class="preview board" href="bd_EK-TM4C123GXL.jpg" title="EK-TM4C123GXL"></a>
- @ref arm-cm_dpp_efm32-slstk3401a <a class="preview board" href="bd_EFM32-SLSTK3401A.jpg" title="EFM32-SLSTK3401A"></a>
- @ref arm-cm_dpp_mbed-lpc1768 <a class="preview board" href="bd_mbed-LPC1768.jpg" title="mbed-LPC1768"></a>
- @ref arm-cm_dpp_nucleo-l053r8 <a class="preview board" href="bd_nucleo-l053r8.jpg" title="NUCLEO-L053R8"></a>
- @ref arm-cm_dpp_nucleo-l152re <a class="preview board" href="bd_nucleo-l152re.jpg" title="NUCLEO-L152RE"></a>
- @ref arm-cm_game_efm32-slstk3401a <a class="preview board" href="bd_EFM32-SLSTK3401A.jpg" title="EFM32-SLSTK3401A"></a>
- @ref arm7-9_dpp_at91sam7s-ek <a class="preview board" href="bd_AT91SAM7S-EK.jpg" title="AT91SAM7S-EK"></a>
@subsection exa_ref_ti-arm TI ARM with CCS IDE
- @ref arm-cm_dpp_ek-tm4c123gxl <a class="preview board" href="bd_EK-TM4C123GXL.jpg" title="EK-TM4C123GXL"></a>
@subsection exa_ref_ccs-430 CCS for MSP430
- @ref msp430_blinky_msp-exp430g2 <a class="preview board" href="bd_MSP-EXP430G2.jpg" title="MSP-EXP430G2"></a>
- @ref msp430_blinky_msp-exp430f5529lp <a class="preview board" href="bd_MSP-EXP430F5529LP.jpg" title="MSP-EXP430F5529LP"></a>
- @ref msp430_dpp_msp-exp430g2 <a class="preview board" href="bd_MSP-EXP430G2.jpg" title="MSP-EXP430G2"></a>
@subsection exa_ref_iar-430 IAR EW430
- @ref msp430_blinky_msp-exp430g2 <a class="preview board" href="bd_MSP-EXP430G2.jpg" title="MSP-EXP430G2"></a>
- @ref msp430_blinky_msp-exp430f5529lp <a class="preview board" href="bd_MSP-EXP430F5529LP.jpg" title="MSP-EXP430F5529LP"></a>
- @ref msp430_dpp_msp-exp430g2 <a class="preview board" href="bd_MSP-EXP430G2.jpg" title="MSP-EXP430G2"></a>
@subsection exa_ref_iar-avr GNU-AVR
- @ref avr_blinky_arduino-uno <a class="preview board" href="bd_Arduino-UNO.jpg" title="Arduino-UNO"></a>
- @ref avr_dpp_arduino-uno <a class="preview board" href="bd_Arduino-UNO.jpg" title="Arduino-UNO"></a>
@subsection exa_ref_iar-avr IAR-AVR
- @ref avr_blinky_arduino-uno <a class="preview board" href="bd_Arduino-UNO.jpg" title="Arduino-UNO"></a>
- @ref avr_dpp_arduino-uno <a class="preview board" href="bd_Arduino-UNO.jpg" title="Arduino-UNO"></a>
@section exa_ref_vendor Examples by MCU Vendor
- Atmel
- @ref arm7-9_dpp_at91sam7s-ek <a class="preview board" href="bd_AT91SAM7S-EK.jpg" title="AT91SAM7S-EK"></a>
- @ref avr_blinky_arduino-uno <a class="preview board" href="bd_Arduino-UNO.jpg" title="Arduino-UNO"></a>
- @ref avr_dpp_arduino-uno <a class="preview board" href="bd_Arduino-UNO.jpg" title="Arduino-UNO"></a>
- NXP
- @ref arm-cm_dpp_mbed-lpc1768 <a class="preview board" href="bd_mbed-LPC1768.jpg" title="mbed-LPC1768"></a>
- Silicon Labs
- @ref arm-cm_blinky_efm32-slstk3401a <a class="preview board" href="bd_EFM32-SLSTK3401A.jpg" title="EFM32-SLSTK3401A"></a>
- @ref arm-cm_dpp_efm32-slstk3401a <a class="preview board" href="bd_EFM32-SLSTK3401A.jpg" title="EFM32-SLSTK3401A"></a>
- @ref arm-cm_game_efm32-slstk3401a <a class="preview board" href="bd_EFM32-SLSTK3401A.jpg" title="EFM32-SLSTK3401A"></a>
- STMicroelectronics
- @ref arm-cm_dpp_nucleo-l053r8 <a class="preview board" href="bd_nucleo-l053r8.jpg" title="NUCLEO-L053R8"></a>
- @ref arm-cm_dpp_nucleo-l152re <a class="preview board" href="bd_nucleo-l152re.jpg" title="NUCLEO-L152RE"></a>
- Texas Instruments
- @ref arm-cm_blinky_ek-tm4c123gxl <a class="preview board" href="bd_EK-TM4C123GXL.jpg" title="EK-TM4C123GXL"></a>
- @ref arm-cm_dpp_ek-tm4c123gxl <a class="preview board" href="bd_EK-TM4C123GXL.jpg" title="EK-TM4C123GXL"></a>
- @ref arm-cm_game_efm32-slstk3401a <a class="preview board" href="bd_EFM32-SLSTK3401A.jpg" title="EFM32-SLSTK3401A"></a>
@next{exa_native}
*/
================================================
FILE: doxygen/exa_apps.dox
================================================
/*##########################################################################*/
/*! @page exa_apps Example Applications
<p>To demonstrate QP-nano features, you need to create an application that does "something interesting". Instead of inventing this "something interesting" for each and every example, most of the example projects implement one of the three example applications, which are described on the separate pages:
</p>
- @subpage blinky
- @subpage pelican
- @subpage dpp
- @subpage game
Additionally, the QP-nano distribution contains several application examples described in the <a class="extern" target="_blank" href="https://www.state-machine.com/psicc2">PSiCC2</a> book.
- Calculator
- QHsmTst
- PELICAN
- ...
*/
/*##########################################################################*/
/*! @page blinky Simple Blinky Application
<p>The ultra-simple Blinky example is the embedded systems' equivalent of the venerable <i>"Hello World!"</i> program, that is, the simplest possible working QP application that does "something". In the case of Blinky, this "something" is blinking an LED at the rate of 1Hz, where an LED turns on and remains on for 0.5 seconds on then turns off and remains off for 0.5 seconds.
</p>
@image html blinky_ek-tm4c123gxl.gif Blinky on EK-TM4C123GLX (TivaC LaunchPad)
The ultra-simple Blinky application, which consists of just one active object named `Blinky`, is intentionally kept small and illustrates only the most basic QP features, such as:
- defining a simple Blinky active object (AO) @ref oop "class";
- hand-coding the simple state machine of the Blinky AO;
- using a periodic time event;
- initializing the QP framework; and
- starting an AO.
@section blinky_sm State Machine
The very simple state machine of the Blinky AO is shown in the figure below:
@image html SM_blinky.png "State Machine of the Blinky AO"
<ul class="tag">
<li><span class="tag">1</span> The top-most initial transition in this state machine arms a QP time event (QTimeEvt_armX()) to deliver the `TIMEOUT` signal every half second, so that the LED can stay on for one half second and off for the other half.
</li>
<li><span class="tag">2</span> The initial transition leads to state "off", which turns the LED off in the entry action (`BSP_ledOff()`).
</li>
<li><span class="tag">3</span> When the `TIMEOUT` event arrives in the "off" state, the "off" state transitions to the "on" state
</li>
<li><span class="tag">4</span> The "on" state turns the LED on in the entry action (`BSP_ledOn()`).
</li>
<li><span class="tag">5</span> When the `TIMEOUT` event arrives in the "on" state, the "on" state transitions back to "off", which cases execution of the entry action, in which the LED is turned off. From that point on the cycle repeats forever because the `TIMEOUT` events keep getting generated at the pre-determined rate.
</li>
</ul>
@section blinky_code State Machine Code
The Blinky state machine shown above is implemented in the blinky.c source file, as shown in the
listing below. The code has been specifically organized not to access target resources directly, but instead encapsulate all such access in the calls to the BSP (Board Support Package). So for example, instead of turning the LED on and off by writing to a specific GPIO register on an embedded board, the code calls the BSP functions `BSP_ledOn()` and `BSP_ledOff()`. These functions can then be defined differently for each Target board (or even a desktop workstation), without the need to change the state machine code.
@note
The Blinky source code (blinky.c) is actually the same on all platforms, including Windows
and the embedded boards. The only difference is in the Board Support Package (bsp.c), which is
specific for the target.
@includelineno examples/arm-cm/blinky_ek-tm4c123gxl/blinky.c
As you can see, the structure of the state machine is very clearly recognizable in this code. Please refer to the Application Note <a class="extern" target="_blank" href="http://state-machine.com/doc/AN_Crash_Course_in_UML_State_Machines.pdf">A Crash Course in UML State Machines</a> for exact explanation of the state machine coding techniques.
@subsection blinky_ao Defining Active Object (AO) Class
- hand-coding the simple state machine of the Blinky AO;
- using a periodic time event;
- initializing the QP framework; and
- starting an AO.
@next{dpp}
*/
/*##########################################################################*/
/*! @page pelican PEdestrian LIght CONtrolled (PELICAN) Crossing
@image html under_construction.jpg
@next{game}
*/
/*##########################################################################*/
/*! @page dpp Dining Philosophers Problem (DPP)
@image html dpp_win32.jpg
@image html under_construction.jpg
@next{game}
*/
/*##########################################################################*/
/*! @page game "Fly 'n' Shoot" Game
@image html game_win32.jpg
@image html under_construction.jpg
*/
================================================
FILE: doxygen/exa_native.dox
================================================
/*##########################################################################*/
/*! @page exa_native Native Examples (Built-in Kernels)
<p>The QP-nano framework contains real-time kernels (@ref comp_qv and @ref comp_qk), so it can run natively ("bare-metal") on single-chip microcontrollers, completely replacing a traditional RTOS. Click on the following links to see examples for the specified built-in kernels:
</p>
- @subpage exa_qv
- @subpage exa_qk
Click on the following links to see examples for the specified CPU architectures:
- @subpage exa_arm-cm
- @subpage exa_arm7-9
- @subpage exa_msp430
- @subpage exa_avr
*/
/*##########################################################################*/
/*! @page exa_qv QV-nano Kernel (Non-Preemptive, Priority-Based, Non-Blocking)
@note
You can hover the mouse cursor over the <span class="board"></span> icon in the list below to see the picture of the board.
- @ref arm-cm_blinky_ek-tm4c123gxl <a class="preview board" href="bd_EK-TM4C123GXL.jpg" title="EK-TM4C123GXL"></a>
- @ref arm-cm_blinky_efm32-slstk3401a <a class="preview board" href="bd_EFM32-SLSTK3401A.jpg" title="EFM32-SLSTK3401A"></a>
- @ref arm-cm_dpp_ek-tm4c123gxl <a class="preview board" href="bd_EK-TM4C123GXL.jpg" title="EK-TM4C123GXL"></a>
- @ref arm-cm_dpp_efm32-slstk3401a <a class="preview board" href="bd_EFM32-SLSTK3401A.jpg" title="EFM32-SLSTK3401A"></a>
- @ref arm-cm_dpp_nucleo-l053r8 <a class="preview board" href="bd_nucleo-l053r8.jpg" title="NUCLEO-L053R8"></a>
- @ref arm-cm_dpp_nucleo-l152re <a class="preview board" href="bd_nucleo-l152re.jpg" title="NUCLEO-L152RE"></a>
- @ref arm-cm_game_efm32-slstk3401a <a class="preview board" href="bd_EFM32-SLSTK3401A.jpg" title="EFM32-SLSTK3401A"></a>
- @ref arm7-9_dpp_at91sam7s-ek <a class="preview board" href="bd_AT91SAM7S-EK.jpg" title="AT91SAM7S-EK"></a>
- @ref msp430_blinky_msp-exp430g2 <a class="preview board" href="bd_MSP-EXP430G2.jpg" title="MSP-EXP430G2"></a>
- @ref msp430_blinky_msp-exp430f5529lp <a class="preview board" href="bd_MSP-EXP430F5529LP.jpg" title="MSP-EXP430F5529LP"></a>
- @ref msp430_dpp_msp-exp430g2 <a class="preview board" href="bd_MSP-EXP430G2.jpg" title="MSP-EXP430G2"></a>
*/
/*##########################################################################*/
/*! @page exa_qk QK-nano Kernel (Preemptive, Priority-Based, Non-Blocking)
@note
You can hover the mouse cursor over the <span class="board"></span> icon in the list below to see the picture of the board.
- @ref arm-cm_blinky_ek-tm4c123gxl <a class="preview board" href="bd_EK-TM4C123GXL.jpg" title="EK-TM4C123GXL"></a>
- @ref arm-cm_blinky_efm32-slstk3401a <a class="preview board" href="bd_EFM32-SLSTK3401A.jpg" title="EFM32-SLSTK3401A"></a>
- @ref arm-cm_dpp_ek-tm4c123gxl <a class="preview board" href="bd_EK-TM4C123GXL.jpg" title="EK-TM4C123GXL"></a>
- @ref arm-cm_dpp_efm32-slstk3401a <a class="preview board" href="bd_EFM32-SLSTK3401A.jpg" title="EFM32-SLSTK3401A"></a>
- @ref arm-cm_dpp_nucleo-l053r8 <a class="preview board" href="bd_nucleo-l053r8.jpg" title="NUCLEO-L053R8"></a>
- @ref arm-cm_dpp_nucleo-l152re <a class="preview board" href="bd_nucleo-l152re.jpg" title="NUCLEO-L152RE"></a>
- @ref arm-cm_game_efm32-slstk3401a <a class="preview board" href="bd_EFM32-SLSTK3401A.jpg" title="EFM32-SLSTK3401A"></a>
- @ref arm7-9_dpp_at91sam7s-ek <a class="preview board" href="bd_AT91SAM7S-EK.jpg" title="AT91SAM7S-EK"></a>
- @ref msp430_blinky_msp-exp430g2 <a class="preview board" href="bd_MSP-EXP430G2.jpg" title="MSP-EXP430G2"></a>
- @ref msp430_blinky_msp-exp430f5529lp <a class="preview board" href="bd_MSP-EXP430F5529LP.jpg" title="MSP-EXP430F5529LP"></a>
- @ref msp430_dpp_msp-exp430g2 <a class="preview board" href="bd_MSP-EXP430G2.jpg" title="MSP-EXP430G2"></a>
*/
/*##########################################################################*/
/*! @page exa_arm-cm ARM Cortex-M (Cortex-M0/M0+/M3/M4F)
@note
You can hover the mouse cursor over the <span class="board"></span> icon in the list below to see the picture of the board.
- @subpage arm-cm_blinky_ek-tm4c123gxl <a class="preview board" href="bd_EK-TM4C123GXL.jpg" title="EK-TM4C123GXL"></a>
- @subpage arm-cm_blinky_efm32-slstk3401a <a class="preview board" href="bd_EFM32-SLSTK3401A.jpg" title="EFM32-SLSTK3401A"></a>
- @subpage arm-cm_dpp_ek-tm4c123gxl <a class="preview board" href="bd_EK-TM4C123GXL.jpg" title="EK-TM4C123GXL"></a>
- @subpage arm-cm_dpp_efm32-slstk3401a <a class="preview board" href="bd_EFM32-SLSTK3401A.jpg" title="EFM32-SLSTK3401A"></a>
- @subpage arm-cm_dpp_mbed-lpc1768 <a class="preview board" href="bd_mbed-LPC1768.jpg" title="mbed-LPC1768"></a>
- @subpage arm-cm_dpp_nucleo-l053r8 <a class="preview board" href="bd_nucleo-l053r8.jpg" title="NUCLEO-L053R8"></a>
- @subpage arm-cm_dpp_nucleo-l152re <a class="preview board" href="bd_nucleo-l152re.jpg" title="NUCLEO-L152RE"></a>
- @subpage arm-cm_game_efm32-slstk3401a <a class="preview board" href="bd_EFM32-SLSTK3401A.jpg" title="EFM32-SLSTK3401A"></a>
*/
/*##########################################################################*/
/*! @page exa_arm7-9 ARM7/ARM9 ("classic" ARM)
@note
You can hover the mouse cursor over the <span class="board"></span> icon in the list below to see the picture of the board.
- @subpage arm7-9_dpp_at91sam7s-ek <a class="preview board" href="bd_AT91SAM7S-EK.jpg" title="AT91SAM7S-EK"></a>
*/
/*##########################################################################*/
/*! @page exa_msp430 MSP430 ("classic" MSP430 and "extended" MSP430x)
@note
You can hover the mouse cursor over the <span class="board"></span> icon in the list below to see the picture of the board.
- @subpage msp430_blinky_msp-exp430g2 <a class="preview board" href="bd_MSP-EXP430G2.jpg" title="MSP-EXP430G2"></a>
- @subpage msp430_blinky_msp-exp430f5529lp <a class="preview board" href="bd_MSP-EXP430F5529LP.jpg" title="MSP-EXP430F5529LP"></a>
- @subpage msp430_dpp_msp-exp430g2 <a class="preview board" href="bd_MSP-EXP430G2.jpg" title="MSP-EXP430G2"></a>
*/
/*##########################################################################*/
/*! @page arm-cm_blinky_ek-tm4c123gxl Blinky on EK-TM4C123GXL
@tableofcontents
<p>This example implements the @ref blinky "Blinky sample application" on the EK-TM4C123GLX board (ARM Cortex-M4F).
</p>
@image html bd_EK-TM4C123GXL.jpg EK-TM4C123GXL board
The Blinky example is located in the directory <span class="img folder">qpc/examples/arm-cm/blinky_ek-tm4c123gxl</span>, which is organized as follows:
@code{.x}
qpn/ - QP-nano installation directory
+-examples/ - QP-nano examples directory (application)
| +-arm-cm/ - QP-nano examples for ARM Cortex-M
| | +-blinky_ek-tm4c123gxl/ - Blinky example on the EK-TM4C123GLX board
| | | +-qk/ - QK version
| | | | +-arm/ - ARM-KEIL toolchain
| | | | | +-blinky-qk.uvprojx - uVision project
| | | | +-gnu/ - GNU-ARM toolchain
| | | | | +-Makefile - Makefile for building the project
| | | | +-iar/ - IAR-ARM toolchain
| | | | | +-blinky-qk.eww - IAR EW-ARM workspace
| | | | +-bsp.c - BSP for the QK-nano kernel
| | | +-qv/ - QV version
| | | | +-arm/ - ARM-KEIL toolchain
| | | | | +-blinky-qk.uvprojx - uVision project
| | | | +-gnu/ - GNU-ARM toolchain
| | | | | +-Makefile - Makefile for building the project with GNU-ARM
| | | | +-iar/ - IAR-ARM toolchain
| | | | | +-blinky-qk.eww - IAR EW-ARM workspace
| | | | +-bsp.c - BSP for the QV-nano kernel
| | | +-win32-qv/ - Windows emulation (single thread)
| | | | +-Makefile - Makefile for building the project with MinGW
| | | | +-bsp.c - BSP for the Win32-QV
@endcode
@section arm-cm_blinky_ek-tm4c123gxl_feat Features Demonstrated
- cooperative QV-nano kernel
+ with ARM-KEIL toolchain
+ with GNU-ARM toolchain
+ with IAR-ARM toolchain
- preemptive run-to-completion QK-nano kernel
+ with ARM-KEIL toolchain
+ with GNU-ARM toolchain
+ with IAR-ARM toolchain
- Windows emulation (console, single threaded: win32-qv)
@section arm-cm_blinky_ek-tm4c123gxl_run Running the Example
Once programmed into the board, the example blinks the on-board LED about once a second.
@image html blinky_ek-tm4c123gxl.gif Blinky on EK-TM4C123GLX (TivaC LaunchPad)
@section arm-cm_blinky_ek-tm4c123gxl_win Windows Emulation
The Windows emulation is a simple console application that produces the following output:
@image html blinky_win32.png Blinky emulation running in a Windows console
@next{arm-cm_blinky_efm32-slstk3401a}
*/
/*##########################################################################*/
/*! @page arm-cm_blinky_efm32-slstk3401a Blinky on EFM32-SLSTK3401A
@tableofcontents
<p>This example implements the @ref blinky "Blinky sample application" on the EFM32-SLSTK3401A board (ARM Cortex-M4F).
</p>
@image html bd_EFM32-SLSTK3401A.jpg EFM32-SLSTK3401A board
The Blinky example is located in the directory <span class="img folder">qpc/examples/arm-cm/blinky_efm32-slstk3401a</span>, which is organized as follows:
@code{.x}
qpn/ - QP-nano installation directory
+-examples/ - QP-nano examples directory (application)
| +-arm-cm/ - QP-nano examples for ARM Cortex-M
| | +-blinky_efm32-slstk3401a/ - Blinky example on the EFM32-SLSTK3401A board
| | | +-qk/ - QK version
| | | | +-arm/ - ARM-KEIL toolchain
| | | | | +-blinky-qk.uvprojx - uVision project
| | | | +-gnu/ - GNU-ARM toolchain
| | | | | +-Makefile - Makefile for building the project
| | | | +-iar/ - IAR-ARM toolchain
| | | | | +-blinky-qk.eww - IAR EW-ARM workspace
| | | | +-bsp.c - BSP for the QK-nano kernel
| | | +-qv/ - QV version
| | | | +-arm/ - ARM-KEIL toolchain
| | | | | +-blinky-qk.uvprojx - uVision project
| | | | +-gnu/ - GNU-ARM toolchain
| | | | | +-Makefile - Makefile for building the project with GNU-ARM
| | | | +-iar/ - IAR-ARM toolchain
| | | | | +-blinky-qk.eww - IAR EW-ARM workspace
| | | | +-bsp.c - BSP for the QV-nano kernel
| | | +-workstation/ - Examples for workstations (Windows, Linux, MacOS)
| | | | +-Makefile - Makefile for building the project with MinGW
| | | | +-bsp.c - BSP for workstations
@endcode
@section arm-cm_blinky_efm32-slstk3401a_feat Features Demonstrated
- cooperative QV-nano kernel
+ with ARM-KEIL toolchain
+ with GNU-ARM toolchain
+ with IAR-ARM toolchain
- preemptive run-to-completion QK-nano kernel
+ with ARM-KEIL toolchain
+ with GNU-ARM toolchain
+ with IAR-ARM toolchain
- Windows emulation (console, single threaded: win32-qv)
@section arm-cm_blinky_efm32-slstk3401a_run Running the Example
Once programmed into the board, the example blinks the on-board LED about once a second.
@section arm-cm_blinky_efm32-slstk3401a_win Windows Emulation
The Windows emulation is a simple console application that produces the following output:
@image html blinky_win32.png Blinky emulation running in a Windows console
@next{arm-cm_dpp_ek-tm4c123gxl}
*/
/*##########################################################################*/
/*! @page arm-cm_dpp_ek-tm4c123gxl DPP on EK-TM4C123GXL
@tableofcontents
<p>This example implements the @ref dpp "Dining Philosophers Problem" sample application on the EK-TM4C123GLX board (ARM Cortex-M4F).
</p>
@image html bd_EK-TM4C123GXL.jpg EK-TM4C123GXL board
The DPP example is located in the directory <span class="img folder">qpc/examples/arm-cm/dpp_ek-tm4c123gxl</span>, which is organized as follows:
@code{.x}
qpn/ - QP-nano installation directory
+-examples/ - QP-nano examples directory (applications)
| +-arm-cm/ - QP-nano examples for ARM Cortex-M
| | +-dpp_ek-tm4c123gxl/ - DPP example on the EK-TM4C123GLX board
| | | +-lint/ - PC-Lint version (static analysis of the application code)
| | | | +-lin.bat - batch file for running the PC-Lint
| | | | +-options.lnt - PC-Lint options file for the DPP application code
| | | +-qk/ - QK version
| | | | +-arm/ - ARM-KEIL toolchain
| | | | | +-dpp-qk.uvprojx - uVision project
| | | | +-gnu/ - GNU-ARM toolchain
| | | | | +-Makefile - Makefile for building the project
| | | | +-iar/ - IAR-ARM toolchain
| | | | | +-dpp-qk.eww - IAR EW-ARM workspace
| | | | +-ti/ - TI-ARM toolchain (CCS)
| | | | | +-.ccsproject - CCS project
| | | | | +-.cproject - C Eclipse project
| | | | | +-.project - Eclipse project
| | | | +-bsp.c - BSP for the QK-nano kernel
| | | | +-main.c - main() for the QK-nano kernel
| | | +-qv/ - QV version
| | | | +-arm/ - ARM-KEIL toolchain
| | | | | +-dpp-qk.uvprojx - uVision project
| | | | +-gnu/ - GNU-ARM toolchain
| | | | | +-Makefile - Makefile for building the project with GNU-ARM
| | | | +-iar/ - IAR-ARM toolchain
| | | | | +-blinky-qk.eww - IAR EW-ARM workspace
| | | | +-bsp.c - BSP for the QV-nano kernel
| | | | +-main.c - main() for the QV-nano kernel
@endcode
@section arm-cm_dpp_ek-tm4c123gxl_feat Features Demonstrated
- cooperative QV-nano kernel
+ with ARM-KEIL toolchain
+ with GNU-ARM toolchain
+ with IAR-ARM toolchain
+ with TI-ARM toolchain (CCS)
- preemptive run-to-completion QK-nano kernel
+ with ARM-KEIL toolchain
+ with GNU-ARM toolchain
+ with IAR-ARM toolchain
+ with TI-ARM toolchain (CCS)
- Windows emulation with GUI (single threaded, win32-qv)
@section arm-cm_dpp_ek-tm4c123gxl_run Running the Example
Once programmed into the board, the example rapidly toggles the Blue LED from the idle loop (blue LED glows) and toggles the Red and Green LEDs as the Philosophers change their state. Additionally, you can depress and hold the SW1 button (left) to PAUSE the application (Table transitions into the "paused" state). Releasing the SW1 button causes transition back to the "serving" state.
*/
/*##########################################################################*/
/*! @page arm-cm_dpp_efm32-slstk3401a DPP on EFM32-SLSTK3401A
@tableofcontents
<p>This example implements the @ref dpp "Dining Philosophers Problem" sample application on the EFM32-SLSTK3401A board (ARM Cortex-M4F).
</p>
@image html bd_EFM32-SLSTK3401A.jpg EFM32-SLSTK3401A board
The DPP example is located in the directory <span class="img folder">qpc/examples/arm-cm/dpp_efm32-slstk3401a</span> and includes versions for @ref qv "cooperative QV-nano kernel", the @ref qk "preemptive QK-nano kernel", and the @ref qxk "preemptive dual mode QXK RTOS kernel" each provided for the ARM-KEIL, GNU-ARM, and IAR-ARM. The following annotated directory listing describes the contents of the example folder:
@code{.x}
qpn/ - QP-nano installation directory
+-examples/ - QP-nano examples directory (application)
| +-arm-cm/ - QP-nano examples for ARM Cortex-M
| | +-dpp_efm32-slstk3401a/ - DPP example on the EK-TM4C123GLX board
| | | +-lint/ - PC-Lint version (static analysis of the application code)
| | | | +-lin.bat - batch file for running the PC-Lint
| | | | +-options.lnt - PC-Lint options file for the DPP application code
| | | +-qk/ - QK version
| | | | +-arm/ - ARM-KEIL toolchain
| | | | | +-dpp-qk.uvprojx - uVision project
| | | | +-gnu/ - GNU-ARM toolchain
| | | | | +-Makefile - Makefile for building the project
| | | | +-iar/ - IAR-ARM toolchain
| | | | | +-dpp-qk.eww - IAR EW-ARM workspace
| | | | +-bsp.c - BSP for the QK-nano kernel
| | | | +-main.c - main() for the QK-nano kernel
| | | +-qv/ - QV version
| | | | +-arm/ - ARM-KEIL toolchain
| | | | | +-dpp-qk.uvprojx - uVision project
| | | | +-gnu/ - GNU-ARM toolchain
| | | | | +-Makefile - Makefile for building the project with GNU-ARM
| | | | +-iar/ - IAR-ARM toolchain
| | | | | +-blinky-qk.eww - IAR EW-ARM workspace
| | | | +-bsp.c - BSP for the QV-nano kernel
| | | | +-main.c - main() for the QV-nano kernel
@endcode
@section arm-cm_dpp_efm32-slstk3401a_feat Features Demonstrated
- cooperative QV-nano kernel
+ with ARM-KEIL toolchain
+ with GNU-ARM toolchain
+ with IAR-ARM toolchain
- preemptive run-to-completion QK-nano kernel
+ with ARM-KEIL toolchain
+ with GNU-ARM toolchain
+ with IAR-ARM toolchain
- Windows emulation with GUI (single threaded, win32-qv)
@section arm-cm_dpp_efm32-slstk3401a_run Running the Example
Once programmed into the board, the example rapidly toggles the LED1 from the idle loop (LED1 glows) and toggles LED0 as the Philosophers change their state. Additionally, you can depress and hold the BTN0 button (left) to PAUSE the application (Table transitions into the "paused" state). Releasing the BTN0 button causes transition back to the "serving" state.
*/
/*##########################################################################*/
/*! @page arm-cm_dpp_mbed-lpc1768 DPP on mbed-LPC1768
@image html bd_mbed-LPC1768.jpg mbed-LPC1768 board
Dining Philosophers Problem (DPP) example for NXP LPC1768 MCU (Cortex-M3) with GNU-ARM toolchain.
@image html mbed-LPC1768_button.jpg Adding External Button to mbed-LPC1768
@n
@n
@image html under_construction.jpg
*/
/*##########################################################################*/
/*! @page arm-cm_dpp_nucleo-l053r8 DPP on NUCLEO-L053R8
@image html bd_nucleo-l053r8.jpg NUCLEO-L053R8 board
@ref dpp "Dining Philosophers Problem (DPP)" example for NUCLEO-L053R8 MCU (Cortex-M0+).
Demonstrated built-in kernels:
- cooperative @ref qv with ARM-Clang, ARM-Keil, GNU-ARM (Makefile and Atollic TRUEstudio), and IAR-ARM toolchains
- preemptive, run-to-completion @ref qk with ARM-Clang, ARM-Keil, GNU-ARM, and IAR-ARM toolchains
Features:
- multiple active objects, including 5 instances of the same AO class (Philo)
- QK_onContextSw() callback function
*/
/*##########################################################################*/
/*! @page arm-cm_dpp_nucleo-l152re DPP on NUCLEO-L152RE
@image html bd_nucleo-l152re.jpg NUCLEO-L152RE board
@ref dpp "Dining Philosophers Problem (DPP)" example for NUCLEO-L152RE MCU (Cortex-M3).
Demonstrated built-in kernels:
- cooperative @ref qv with ARM-Clang, ARM-Keil, GNU-ARM, and IAR-ARM toolchains
- preemptive, run-to-completion @ref qk with ARM-Clang, ARM-Keil, GNU-ARM, and IAR-ARM toolchains
Features:
- multiple active objects, including 5 instances of the same AO class (Philo)
*/
/*##########################################################################*/
/*! @page arm-cm_game_efm32-slstk3401a "Fly 'n' Shoot" Game on EFM32-SLSTK3401A
@image html bd_EFM32-SLSTK3401A.jpg EFM32-SLSTK3401A board
"Fly 'n' Shoot" game example for Silicon Labs Pearl Gecko MCU (Cortex-M4F), ARM (MDK-ARM), GNU-ARM, IAR EWARM toolsets.
@image html game_win32.png Game emulation running in Windows GUI
@n
@n
@image html under_construction.jpg
*/
/*##########################################################################*/
/*! @page exa_arm7-9 ARM7 / ARM9
The native (bare-metal) QP-nano examples for the "classic" ARM7/ARM9 are as follows:
- @subpage arm7-9_dpp_at91sam7s-ek <a class="preview board" href="bd_AT91SAM7S-EK.jpg" title="AT91SAM7S-EK"></a>
*/
/*##########################################################################*/
/*! @page arm7-9_dpp_at91sam7s-ek DPP on AT91SAM7S-EK
@image html bd_AT91SAM7S-EK.jpg AT91SAM7S-EK board
Dining Philosophers Problem (DPP) example for Atmel AT91SAM7S MCU (ARM7) with GNU-ARM toolset.
@image html under_construction.jpg
*/
/*##########################################################################*/
/*! @page exa_avr AVR (AVRmega)
The native (bare-metal) QP-nano examples for the 8-bit AVRmega are as follows:
- @subpage avr_blinky_arduino-uno <a class="preview board" href="bd_Arduino-UNO.jpg" title="Arduino-UNO"></a>
- @subpage avr_dpp_arduino-uno <a class="preview board" href="bd_Arduino-UNO.jpg" title="Arduino-UNO"></a>
*/
/*##########################################################################*/
/*! @page avr_blinky_arduino-uno Blinky on Arduino-UNO
@image html bd_Arduino-UNO.jpg Arduino-UNO board
Simple Blinky example for Arduino-UNO with GNU-AVR and IAR-AVR toolsets.
@image html under_construction.jpg
*/
/*##########################################################################*/
/*! @page avr_dpp_arduino-uno DPP on Arduino-UNO
@image html bd_Arduino-UNO.jpg Arduino-UNO board
Dining Philosophers Problem (DPP) example for Arduino-UNO with GNU-AVR and IAR-AVR toolsets.
@image html Arduino-UNO_button.jpg Adding External Button to Arduino-UNO
@n
@n
@image html Arduino-UNO_button_schem.jpg External Button Schematics
@n
@n
@image html under_construction.jpg
*/
/*##########################################################################*/
/*! @page exa_msp430 MSP430
The native (bare-metal) QP-nano examples for MSP430 are as follows:
- @subpage msp430_blinky_msp-exp430g2 <a class="preview board" href="bd_MSP-EXP430G2.jpg" title="MSP-EXP430G2"></a>
- @subpage msp430_blinky_msp-exp430f5529lp <a class="preview board" href="bd_MSP-EXP430F5529LP.jpg" title="MSP-EXP430F5529LP"></a>
- @subpage msp430_dpp_msp-exp430g2 <a class="preview board" href="bd_MSP-EXP430G2.jpg" title="MSP-EXP430G2"></a>
*/
/*##########################################################################*/
/*! @page msp430_blinky_msp-exp430g2 Blinky on MSP-EXP430G2
@image html bd_MSP-EXP430G2.jpg MSP-EXP430G2 board
Simple Blinky example for MSP-EXP430G2 with CCS-430 and IAR-430 toolsets.
@image html under_construction.jpg
*/
/*##########################################################################*/
/*! @page msp430_blinky_msp-exp430f5529lp Blinky on MSP-EXP430F5529LP
@image html bd_MSP-EXP430F5529LP.jpg MSP-EXP430F5529LP board
Simple Blinky example for MSP-EXP430F5529LP with CCS-430 and IAR-430 toolsets.
@image html under_construction.jpg
*/
/*##########################################################################*/
/*! @page msp430_dpp_msp-exp430g2 DPP on MSP-EXP430G2
@image html bd_MSP-EXP430G2.jpg MSP-EXP430G2 board
DPP example for MSP-EXP430G2 with CCS-430 and IAR-430 toolsets.
@image html under_construction.jpg
*/
================================================
FILE: doxygen/exa_os.dox
================================================
/*##########################################################################*/
/*! @page exa_os Examples for Workstations (Windows/POSIX)
<p>The <span class="img folder">examples/workstation</span> folder contains all examples described in the book <a class="extern" target="_blank" href="https://www.state-machine.com/psicc2" >Practical UML Statecharts in C/C++, 2nd Edition</a> and more. These examples include:
</p>
- <span class="img folder">blinky</span> Simple "Blinky" for Windows (command line)
- <span class="img folder">calc</span> Calculator example from Chapter 2 of PSiCC2
- <span class="img folder">comp</span> Orthogonal Component design pattern
- <span class="img folder">comp_qm</span> Orthogonal Component with QM model design pattern
- <span class="img folder">defer</span> Deferred Event design pattern
- <span class="img folder">dpp</span> DPP (command-line)
- <span class="img folder">dpp-comp</span> DPP with the "Orthogonal Component" pattern (command-line)
- <span class="img folder">dpp-gui</span> DPP (with GUI on Windows)
- <span class="img folder">game-gui</span> "Fly 'n' Shoot" game from Chapter 1 of PSiCC2
- <span class="img folder">history</span> Transition-to-History design pattern (hand-coded)
- <span class="img folder">pelican</span> PEdestrian LIgth CONtrolled Crossing (command line)
- <span class="img folder">qhsmtst</span> Test State Machine based on ::QHsm with QM model
- <span class="img folder">reminder</span> Reminder design pattern from Chapter 5 of PSiCC2
- <span class="img folder">reminder2</span> Reminder design pattern different version
@sa
@ref win32-qv "QP-nano Win32-QV Emulation"
*/
================================================
FILE: doxygen/gs.dox
================================================
/*! @page gs Getting Started
@section gs_obtain Downloading & Installing QP-nano™
@tableofcontents
<p>The most recommended way of obtaining QP-nano™ is by downloading the <a class="extern" target="_blank" href="https://www.state-machine.com/#Downloads"><b>QP-bundle™</b></a>, which includes QP-nano™ as well as other QP frameworks and also the <a class="extern" target="_blank" href="https://www.state-machine.com/qm/">QM™ modeling tool</a> and the <a class="extern" target="_blank" href="https://www.state-machine.com/products/">QTools™ collection</a>. The main advantage of obtaining QP-nano™ bundled together like that is that you get all components, tools and examples ready to go.
@note
<a class="extern" target="_blank" href="https://www.state-machine.com/#Downloads"><strong>QP-bundle™</strong></a> is the **most recommended** way of downloading and installing QP-nano™. However, if you are allergic to installers and GUIs or don't have administrator privileges you can also **download and install QP-nano™ separately** as described in the Application Note: "Getting Started with QP-nano" below.
@section gs_an Getting Started with QP-nano App Note
The Quantum Leaps Application Note <a class="extern" target="_blank" href="https://www.state-machine.com/doc/AN_Getting_Started_with_QP-nano.pdf"><strong>Getting Started with QP-nano</strong></a> provides step-by-step instructions on how to get started with QP-nano quickly.
@htmlonly
<div class="image">
<a target="_blank" href="https://www.state-machine.com/doc/AN_Getting_Started_with_QP-nano.pdf"><img border="0" src="img/AN_Getting_Started_with_QP-nano.jpg" title="Download PDF"></a>
<div class="caption">
Application Note: Getting Started with QP-nano
</div>
</div>
@endhtmlonly
@section gs_files Directories and Files
The following annotated directory tree lists the top-level directories provided in the standard QP-nano distribution.
<ul class="tag">
<li><span class="img folder">qpn</span>
</li>
<ul class="tag">
<li><span class="img folder">3rd_party</span> — Third-Party code used in the QP-nano @ref ports "ports" and @ref exa "examples"
</li>
<li><span class="img folder">examples</span> — @ref exa "QP-nano Examples"
</li>
<li><span class="img folder">ports</span> — @ref ports "QP-nano Ports"
</li>
<li><span class="img folder">include</span> — Platform-independent QP-nano API (see <a href="dir_d44c64559bbebec7f509842c48db8b23.html"><strong>include</strong></a>)
</li>
<li><span class="img folder">source</span> — Platform-independent QP-nano source code (see @ref <a href="dir_b2f33c71d4aa5e7af42a1ca61ff5af1b.html"><strong>source</strong></a>)
</li>
</ul>
</ul>
@note
The standard QP-nano distribution contains many @ref exa "Example Projects", which are specifically designed to help you learn to use QP-nano and to serve you as starting points for your own projects.
@next{struct}
*/
================================================
FILE: doxygen/history.dox
================================================
/**
@page history Revision History
@section qpn_6_9_0 Version 6.9.0, 2020-08-21
- Applied the Doxygen commands `extends` and `memberof` to indicate inheritance and to explicitly specify base classes for all derived classes (e.g., QActive extends QHsm).
- Fixed some errors in documentation comments in source code, etc.
- Bumped version to 6.9.0 for compatibility with QM 5.1.3
@attention
This is the last QP-nano release. The QP-nano framework is being __phased out__ and is not recommended for new product development.
@section qpn_6_8_2 Version 6.8.2, 2020-06-30
- Updated 3rd_party/CMSIS to version 5.7.0
- Updated example projects for ARM Cortex-M with ARM/KEIL to use the startup in the odler ARM assembly (as opposed to ARMCLANG assembly)
- Updated the doxygen styling
@section qpn_6_8_1 Version 6.8.1, 2020-04-04
Fixedhe following bugs:
This release updates the QP-nano ports and examples for workstations (Windows and POSIX) by consistently applying the "safe" versions of services from `<stdio.h>` and `<string.h>`. The "portable" versions of these services are defined as macros in the `safe_std.h` header file and include the following services:
- `MEMMOVE_S()` -> `memmove_s()`
- `STRCPY_S()` -> `strcpy_s()`
- `STRCPY_S()` -> `strcpy_s()`
- `STRCAT_S()` -> `strcat_s()`
- `SNPRINTF_S()` -> `_snprintf_s()`
- `PRINTF_S()` -> `printf_s()`
- `FPRINTF_S()` ->`fprintf_s()`
- `FREAD_S()` -> `fread_s()`
- `FOPEN_S()` -> `fopen_s()`
- `LOCALTIME_S()` -> `localtime_s()`
These "safe" functions are mapped to the best approximation of these services available on a given platform. For example, `STRCPY_S()` is mapped to `strcpy_s()` on Windows and `strcpy()` on POSIX (Linux/MacOS/etc.).
Finally, this release consistently applies the #Q_NORETURN macro to the Q_onAssert() implementations in the QP-nano examples.
@section qpn_6_8_0 Version 6.8.0, 2020-03-21
Source code changes:
- Fixed inconsistencies between QP API declarations in the .h files and definitions in the .c files, such as different parameter names in declarations and definitions (MISRA-C:2012).
- Removed a lot of excessive type casting of compile-time constants, such as `(uint8_t)0`, which is now coded simply as `0U`
- Introduced #Q_NORETURN macro for Q_onAssert(), which can (if defined) inform the compiler that Q_onAssert() does not return. This can potentially improve the code generation and can improve diagnostics generated by the compiler as well as static code analysis tools.
Updated Examples:
Converted most of the examples for ARM-MDK from the no-longer maintained compiler-5 (RVDS) to the new ARM Compiler-6 (ARM-clang). The examples for ARM Compiler-6 are located in the `armclang` sub-directories.
@note
The older ARM Compiler-5 is still supported, but will be phased out in the future. The only examples for ARM Compiler-5 are for the EK-TM4C123GXL (TivaC LanuchPad) board. These examples are located in the `arm` sub-directories.
@section qpn_6_7_0 Version 6.7.0, 2019-12-30
The main purpose of this release is providing improved compliance with MISRA-C:2012 (including MISRA-C:2012-Amendment-1) and also to provide support for the [<b>PC-Lint-Plus</b>](https://www.gimpel.com/) static analysis tool (see also feature request [#169](https://sourceforge.net/p/qpc/feature-requests/169/)). Specifically, the QP-nano source code and some examples have been adjusted to comply with MISRA-C:2012-Amendment-1 rules, with all deviations captured in the PC-Lint-Plus configuration files. These PC-Lint-Plus configuration files have been provided in the new "port" to PC-Lint-Plus in the directory qpn/ports/lint-plus/.
@note
The support for the older PC-Lint 9.x and the older MISRA-C:2004 has been dropped to avoid confusion and conflicts with the newer MISRA-C:2012 and the newer PC-Lint-Plus.
This release also includes the offline documentation for **this** particular version of QP-nano (in the `html/` folder). To view the offline documentation, open the file `html/index.html` in your web browser. (The online HTML documention for the **latest** version of QP-nano remains located at: https://www.state-machine.com/qpc/ )
Also, this release drops (no longer supports) the following depricated facilities from the qpn.h header file:
- Q_ROM_VAR - just remove from your code
- Q_RENTRANT - just remove from your code
- QMSM_INIT() - use QHSM_INIT() instead
- QMSM_DISPATCH() - use QHSM_DISPATCH() instead
- QF_onIdle() - use QV_onIdle() instead
- QMsm_ctor() - use QHsm_ctor() instead
- QMsm_init() - use QHSM_INIT() instead
- QMsm_dispatch() - use QHSM_DISPATCH() instead
- QMActive_ctor() - use QActive_ctor() instead
- QMsm_init() - use QHSM_INIT() instead
- QActive_post() - use QACTIVE_POST() instead
- QActive_postISR() - use QACTIVE_POST_ISR() instead
- QActive_arm() - use QActive_armX() instead
- QActive_disarm() - use QActive_disarmX() instead
- Q_TIMERSET - define QF_TIMEEVT_USAGE instead
Also, this release updates the Windows-GUI examples with the QWIN Prototyping Toolkit to work with the latest Visual Studio 2019 and specifically with the Resource Editor now available. Specifically here, the Game-GUI example (qpn\examples\arm-cm\game_efm32-slstk3401a\win32-gui) and the DPP-GUI example (qpn\examples\arm-cm\dpp_efm32-slstk3401a\win32-gui) have been updated to build with the Visual Studio 2019.
Finally, this release fixes the following bugs:
- [bug#255 "IAR-ARM "Multi-file Compilation" fails for QK and QXK applications"](https://sourceforg/bugs/255/)
@section qpn_6_6_0 Version 6.6.0, 2019-10-31
The main purpose of this release is the change in distribution of the QP-nano framework, which is now bundled together with the other QP frameworks (QP/C and QP/C++) as well as QM, and the QTools collection into "QP-bundle". This "QP-bundle" provides a single, streamlined and simplified download and installation of all QP frameworks and all the accompanying tools.
This release brings also the following changes:
- removed "//" (double slash) from all comments for compliance with the MISRA-C:2012 required Rule 3.1. (The "//" sequence was used in the URLs, such as "http://...").
- converted inclusion guards in header files to uppercase as per coding convention for macros.
- replaced "vtbl" with "vtable" in QP-nano source code
- extended the range of #Q_PARAM_SIZE to 8 (8 corresponding to uint64_t)
- fixed [bug#252 qassert.h used as standalone in qpn](https://sourceforge.net/p/qpc/bugs/252/)
@section qpn_6_5_1 Version 6.5.1, 2019-06-11
This release adds ports and examples for PIC24/dsPIC 16-bit MCUs with MPLAB-X and XC16 compiler toolchain.
@section qpn_6_5_0 Version 6.5.0, 2019-03-30
This QP-nano release matches the [QM release 4.5.0](https://www.state-machine.com/qm/history.html#qm_4_5_0), which introduced new implementation for QP/C++. Even though this has no impact on the QP-nano state machine implementation with QM, this release is needed for compatibility checking between QP and QM. This release comes with several models for **QM 4.5.0**.
@section qpn_6_4_0 Version 6.4.0, 2019-02-10
This release brings the following changes:
- added assertion to QHSM_INIT() to make sure the the virtual-pinter (vptr) is initialized
@note
These additional assertions require #Q_DEFINE_THIS_FILE or #Q_DEFINE_THIS_MODULE at the top of the .c file that calls QHSM_INIT().
- modified qassert.h to work correctly when assertions are disabled with #Q_NASSERT and also updated the QP/C source code to build correctly without assertions
- modified Makefiles for workstations (Windows and POSIX) to use compiler options -std=c99 for C and -std=c++11 for C++ as well as -pedantic option.
@section qpn_6_3_8 Version 6.3.8, 2018-12-31
The main purpose of this release is the update the `Makefiles` that use the [GNU-ARM Embedded Toolchain](https://developer.arm.com/open-source/gnu-toolchain/gnu-rm) to match the recent update in [QTools for Windows 6.3.8](https://sourceforge.net/projects/qpc/files/QTools/). Specifically, all `Makefiles` in the `examples` directory have been updated to use the GNU-ARM toolchain located in `qtools\gnu_arm-none-eabi` and use the tools prefix **arm-none-eabi-**.
@note
The `Makefiles` that use the GNU-ARM included in this release require [QTools for Windows version 6.3.8 or newer](https://sourceforge.net/projects/qpc/files/QTools/) and will **NOT** work with the older QTools collection.
@section qpn_6_3_7 Version 6.3.7, 2018-12-07
The main purpose of this release is re-designing of the @ref exa_os "examples for workstations" (previously `win32-qv` and `posix-qv`). All these types of examples have been consolidated in the @ref exa_os "exampes/workstation" folder, where the provided `Makefiles` have been extended to be cross-platform so that they work on Windows, Linux, and MacOS without changes. To facilitate the creation of truly portable, cross-platform examples, the existing @ref ports_os "QP ports to Windows/POSIX" have been augmented with abstractions for portable console access.
@section qpn_6_3_3 Version 6.3.3, 2018-06-22
This release fixes the following bugs:
- [bugs:#218 "__flash attribute in avr port"](https://sourceforge.net/p/qpc/bugs/218/)
- [bug#216 "Generated code for QP version check violates MISRA-C Rule 10.1"](https://sourceforge.net/p/qpc/bugs/216/).
- [bug#217 "GNU-ARM -fstack-protector incompatible with the QP ports to GNU-ARM"](https://sourceforge.net/p/qpc/bugs/217/).
- [bug#215 "QP is internally inconsistent in calling assertion macros"](https://sourceforge.net/p/qpc/bugs/215/).
Also, this release demonstrates the new features of QM 4.3.0 in several example models (qpn/examples/ directory).
Finally, this release updates `3rd_party/CMSIS/Include` to the latest version from GitHub.
@section qpn_6_3_0 Version 6.3.0, 2018-05-10
This release improves the command-line scripts for flash programming of the supported MCUs. Specifically, the flash.bat batch files for EFM32-SLSTK3401A, EK-TM4C123GXL, and for Arudino UNO have been updated.
@section qpn_6_2_0 Version 6.2.0, 2018-03-16
This release updates the QP-nano ports to win32-qv and posix-qv to allow a "tickless" mode, where the "tickerThread" is not created. This mode is set by configuring the system clock tick rate to 0 (QF_setTickRate(0)).
Additionally, this revision updates the posix-qv port implementation to wait for the condition variable in a customary wile() loop.
@section qpn_6_1_1 Version 6.1.1, 2018-02-18
The main purpose of this release is adding the context-switch callback to the preemptive @ref qkn "QK-nano" kernel. The QK_onContextSw() callback function provides a mechanism to perform additional custom operations when QK switches context from one thread to another. To avoid extra overhead when this functionality is not needed and for backwards-compatiblity with the existing applications, the callback is enabled only when the macro #QK_ON_CONTEXT_SW is defined. The macro can be defined either directly in command-line for the compiler, or in the QK-nano port file (qpn_port.h). Examples for the context-switch callbacks have been provided for the @ref arm-cm_dpp_nucleo-l053r8 "NUCLEO-L053R8" (Cortex-M0+) and the @ref arm-cm_dpp_ek-tm4c123gxl "EK-TM4C123GXL" (Cortex-M4F).
Another purpose of this release is adding the support for the [<strong>ARM Compiler 6 (ARM-Clang)</strong>](https://developer.arm.com/products/software-development-tools/compilers/arm-compiler), which is a C/C++ toolchain for ARM processors based on the modern [Clang frontend](https://clang.llvm.org/) and the [LLVM framework](https://llvm.org/). This release adds the ARM-Clang ports and examples for all built-in kernels (QV-nano and QK-nano) for the ARM Cortex-M CPU cores.
Also, this release changes the ARM Cortex-M ports for the IAR-ARM toolchain in that it replaces the assembly modules with the equivalent C implementation. All existing example projects for IAR-ARM have been updated to use the `qkn_port.c` files instead of `qkn_port.s` files.
Also, this release adds new project files for the Atollic TRUEstudio for STM32. The TRUEstudio projects (Eclipse) have been added for the @ref arm-cm_dpp_nucleo-l053r8 "NUCLEO-L053R8" (Cortex-M0+) and the @ref arm-cm_dpp_nucleo-l152re "NUCLEO-L152RE" (Cortex-M3).
Finally, this relese updates the CMSIS to version 5.3.0 (see `qpn/3rd_party/CMSIS`
@section qpn_6_0_4 Version 6.0.4, 2018-01-10
This release replaces assembly with C implementation in the ARM-KEIL ports or the QK-nano kernel to Cortex-M to take advantage of the `__asm` functions. (NOTE: this change has impact on the existing QP-nano applications that use the ARM-KEIL toolchain and the QK kernel.)
Also, this release adds an example of the Dining Philosophers Problem (DPP) re-designed with the ["Orthogonal Component" state pattern](https://www.state-machine.com/doc/Pattern_Orthogonal.pdf). The application uses only one active object (Table), while the Philos are stateful components of Table. The example is located in `qpn\examples\win32-qv\dpp_comp`.
@section qpn_6_0_3 Version 6.0.3, 2017-12-12
This release replaces attributes of ::QActive class and ::QTimeEvtCtr type from type uint_fast8_t to uint8_t. For the ARM Cortex-M port, these changes reduce the memory footprint of each ::QActive instance from 40 to 26 bytes (35% improvement).
Also, the ARM Cortex-M port and examples for the TI-ARM compiler have been removed. (Projects for the TI CCS can use the GNU-ARM toolchain and the existing GNU-ARM ports).
@section qpn_6_0_1 Version 6.0.1, 2017-11-10
This release includes a workaround for the GNU-ARM compiler bug for the ARMv6-M architecture (Cortex-M0/M0+/M1), which can lead to generation of incorrect code for the QP-nano critical section at certain gcc optimization levels (such as -O). This bug was first discovered and filed as [bug#184](https://sourceforge.net/p/qpc/bugs/184/). The bug affected the GNU-ARM ports to both built-in kernels @ref qvn "QV-nano" and @ref qkn "QK-nano".
@attention
This release no longer contains the directory `qpn/source`, which was scheduled to be phased out in QP5. In QP6 the source code is found only in the `qpn/src` directory.
@note
This QP-nano 6.0.1 release is the minimum version required in the upcoming QM 4.1.0.
@section qpn_5_9_8 Version 5.9.8, 2017-09-15
This release implements the feature request
<a href="https://sourceforge.net/p/qpc/feature-requests/126/" target="_blank" class="extern">#126</a> "Allow non-asserting
event posting for zero-margin allocations". Specifically, calling
ACTIVE_POST_X() and ACTIVE_POST_X_ISR() with the margin argument of zero
will no longer assert if the allocation/posting fails.
The asserting version is these macros uses the special value of the @p margin
argument of #QF_NO_MARGIN.
Improved comments in the soruce code.
Modifed ARM Cortex-M examples with the GNU-ARM toolset to be consistent with QP/C++ (support for RTTI and C++ Exception handling), as follows:
- removed definitions of `_init()` and `_fini()` from the GNU-ARM startup code for all supported boards in the `3rd_party` directory
- commented out the call to `__libc_init_array()` in the GNU-ARM startup code for all supported boards in the `3rd_party` directory (because it requires `_init()`)
- Modified all GNU-ARM linker scripts (.ld files) to add the following symbols:
@verbatim
__exidx_start = .;
.ARM.exidx : { *(.ARM.exidx* .gnu.linkonce.armexidx.*) } >RAM
__exidx_end = .;
@endverbatim
-----------------------------------------------------------------------------
@section qpn_5_9_7 Version 5.9.7, 2017-08-18
This release phases out the QK-nano mutex and replaces it with an equivalent selective QK-nano scheduler locking up to the specified ceiling priority. Specifically, this feature has been implemented with two new operations QK_schedLock() and QK_schedUnlock(). This is done with consistency with the QK and QXK kernels in QP/C/C++. The advantage of the new implementation is also the ability of the scheduler locks to nest, which was not the case with the QK-nano mutex.
All related QK-nano examples have been updated to use the selective scheduler locking instead of the mutex. The new blocking QXK mutex has been demonstrated in the following updated examples:
- @ref arm-cm_dpp_efm32-slstk3401a
- @ref arm-cm_dpp_ek-tm4c123gxl
@attention
The changes to QK-nano **break backwards-compatibly** with the existing code that relies these features. In the existing code, the mutexes should be replaced with selective scheduler locking.
This release also updates CMSIS to version 5.1.0 (3rd_party/CMSIS).
This release also adds the @ref api "API Reference" section to the QP-nano documentation.
-----------------------------------------------------------------------------
@section qpn_5_9_6 Version 5.9.6, 2017-08-04
This release changes the organization of the QP-nano source code to make it more friendly for the Eclipse CDT, as proposed in the <a href="https://sourceforge.net/p/qpc/feature-requests/123/" target="_blank" class="extern">feature request #123 "Eclipse-friendly source directory structure for QP"</a>. Specifically, the QP-nano source code is now provided in the `qpn/src/` directory with the following structure:
@verbatim
qpn\
+-source\ - exitsting source directory with "flat" structure
| (for backwards-compatibility)
+-src\ - new source directory grouped by functionality
+-qfn\ - core framework (QEP-nano + QF-nano)
+-qkn\ - QK-nano kernel
+-qvn\ - QV-nano kernel
@endverbatim
This release consistently changes all example projects (for all toolchains) to use the **src/** directory for QP-nano source code, instead of the **source/** directory.
@note The original `qpn/source` directory is still provided for backwards compatibility with the existing QP-nano projects. This directory will be phased out in the future QP-nano releases. Please use the new source code structure provided in the `qpn/src` directory.
Finally, this release adds protection in the IRQ priorities initialization in QK-nano/QV-nano for ARM Cortex-M3/M4/M7, so that the number of IRQs is extracted from bits 0-2 of the ICTR register (INTLINESNUM).
@section qpn_5_9_5 Version 5.9.5, 2017-07-20
This release fixes the following bug:
- <a href="https://sourceforge.net/p/qpc/bugs/178/" class="extern">bug#178</a> "GNU-ARM compiler reports "Error: unaligned opcodes..." in startup code for QP/C/C++/nano examples". The bug fix entails modifying the startup code for the GNU-ARM compiler in the `3rd_party` directory. Specifically, the proper alignment directives have been added to the inline assembly in the exception handlers.
@section qpn_5_9_3 Version 5.9.3, 2017-07-03
This release fixes the following bugs:
- bug#176 "Incorrect initialization of PendSV interrupt priority in
QK-nano for ARM Cortex-M0/M0+"
(https://sourceforge.net/p/qpc/bugs/176/)
- bug#162 "QF critical sections require modification for M7 core"
https://sourceforge.net/p/qpc/bugs/162/
Additionally, this release adapts the Makefiles for GNU-ARM to the new
location of the GNU-ARM toolset, which is now included in the QTools
Collection (v 5.9.1) for Windows.
This release also upgrades CMSIS to version 5.0.2.
@section qpn_5_8_2 Version 5.8.2, 2017-02-08
This release improves compatibility of assertion numbering between
QP-nano and QP/C/C++. Specifically, qepn.c file now uses the same
assertion-IDs as qep_hsm.c (QP/C) and qep_hsm.cpp (QP/C++).
This release upgrades CMSIS to version 5.0.1.
Finally, this release fixes the following bugs:
- bug#152 Typo (qpc\ports\arm7-9\qk\gnu\qk_port.s:42) prevents compilation
@section qpn_5_8_1 Version 5.8.1, 2016-12-16
This release is in response to a recent finding that many QP users of the
ports to ARM Cortex-M3/M4 forget to explicitly set their interrupt priorities,
as described in the AppNote <a href="https://www.state-machine.com/doc/AN_ARM-Cortex-M_Interrupt-Priorities.pdf" target="_blank" class="extern">"Setting ARM Cortex-M Interrupt Priorities in QP 5.x"</a>.
Specifically, this release improves safety of QP ports to ARM Cortex-M3/M4,
by initializing the interrupt priorities to a safe default in a generic,
portable way. This QP port includes such a fix for QV-nano/QK-nano ports to ARM Cortex-M3/M4.
Changes in detail:
- modified the QV and QK source code to call QV_init() and QK_init(), respectively.
- modified the ARM Cortex-M ports of QV-nano and QK-nano to initialize
priorities all exceptions and IRQs to the safe value #QF_BASEPRI.
@note The QV-nano ports to ARM Cortex-M now have a new **qvn_port.c** module that needs to
be added to the build.
- added the header file **cmsis_ccs.h** to qpc/3rd_party/CMSIS/Include directory
(used in the examples for the Code Composer Studio). The file has been
dropped during the upgrade to CMSIS 5.0.1, because it is not part of the
standard distribution.
@section qpn_5_8_0 Version 5.8.0, 2016-11-07
This release simplifies the QP-nano framework by removing the QMsm-style
state machine implementation strategy introduced in version 5.0.0. Moving
forward, the only supported state machine implementation strategy in
QP-nano will be the QHsm-strategy and the upcoming QM 4.x will provide
only the QHsm-strategy for QP-nano applications.
Specifically, the QMsm base class, and QMActive base class have been
removed, along with the accompanying macros. The QP-nano compatibility
layer (file qpn.h) provides some of these macros for backwards-
compatibility, but the underlying implementation must be, in fact,
based on QHsm.
All examples and QM models have been updated to use only the QHsm-style
implementation strategy. The models also require the new upcoming QM 4.0.0.
Additionally, this release fixes the following bugs:
-bug#144 Obsolete Win32 API in qwin_gui.c
Finally, this release includes the latest CMSIS-5, which now replaces the
older CMSIS-4.5.
@section qpn_5_7_3 Version 5.7.3, 2016-10-07
This release fixes the following bugs:
- bug#140 (PendSV_Handler() exception stacked PC not halfword aligned).
@section qpn_5_7_2 Version 5.7.2, 2016-09-30
This release changes the internal QK-nano implementation to match the QK
kernel implementation used in QP/C and QP/C++. (e.g., QK_sched_() has been
renamed to QK_activate_() and QK_schedPrio_() to QK_sched_()). These
changes fall into the category of refactoring and have no impact on the API
or performance.
@section qpn_5_7_0 Version 5.7.0, 2016-08-31
This release release changes once more the QK-nano port to ARM Cortex-M, to reduce the interrupt latecy. This has been achieved by shortening the critical section in the PendSV exception. Also, this QK port to Cortex-M no longer uses the NMI exception.
Finally, this release replaces all absolute paths with relative paths in all CCS-Eclipse project files (for TivaC, Hercules, and MSP430).
@section qpn_5_6_5 Version 5.6.5, 2016-06-09
This release adds support for the new board: EFM32-SLSTK3401A (Pearl Gecko Starter Kit from Silicon Labs). This board replaces the Stellaris EK-LM3S811 board, which has been discontinued. (The Stellaris EK-LM3S811 board had been used in the "Fly 'n' Shoot" game example accompanying the PSiCC2 book).
This release also introduces a new version of the QWIN GUI Toolkit in the Windows prototypes for the "Fly 'n' Shoot" game and the DPP-GUI
version (see https://www.state-machine.com/products/index#QWIN).
Additionally, this release also includes the QP-nano integration with the emWin emgedded GUI from SEGGER, which is also the same product as
uC/GUI distributed by Micrium (@ref exa_emwin).
Finally, this relase comes with updated project files for TI Code Composer Studio (both for ARM Cortex-M and for MSP430).
This release fixes the following bugs:
- bug#130 (POSIX port stop->start leads to reuse of sestroyed mutex).
@section qpn_5_6_4 Version 5.6.4, 2016-04-25
This release fixes two serious bugs:
- Bug #126 (https://sourceforge.net/p/qpc/bugs/126 ) in the QK preemptive scheduler introduced in QP 5.6.2.
- Bug #128 (https://sourceforge.net/p/qpc/bugs/128 ) in the QK port to ARM Cortex-M introduced back in QP 5.6.1
@section qpn_5_6_2 Version 5.6.2, 2016-04-06
The main purpose of this release is to eliminate the need to define the QF_MAX_ACTIVE macro (the number of active objects) in qpn_conf.h header file and match it with the dimension of the QF_active[] global array.
Instead, starting with this QP-nano version, the dimension of the QF_active[] array can be passed as the argument to the QF_init() function, as follows: QF_init(Q_DIM(QF_active));
@note For backwards compatibility the QF_MAX_ACTIVE macro, if defined, is still recognized and calling QF_init(Q_DIM(QF_active)) from main() is not necessary.
Changes in detail:
1. Added internal variable QF_maxActive_ to store the number of active objects and replaced all occurrences of QF_MAX_ACTIVE with it.
2. Moved the implementation of QF_init() from qfn_init.c to qfn.c and changed it to take the maxActive argument.
3. Eliminated the source file qfn_init.c.
4. Modified the POSIX-QV port to use the new initialization strategy
5. Modified the WIN32-QV port to use the new initialization strategy
6. Removed the macro QF_MAX_ACTIVE from all examples and added call to QF_init(Q_DIM(QF_active)) instead.
7. Fixed the 3rd-party file startup_stm32l32l1xx.c to include exceptions for Cortex-M3 (MemManage_Handler, BusFault_Handler, and UsageFault_Handler).
8. Updated the 3rd-party files for the EK-TM4C123GXL board (TivaC LaunchPad).
@section qpn_5_6_1 Version 5.6.1, 2016-01-11
This QP-nano release provides a new version of the QK-nano ports to ARM Cortex-M, which do not use the SVC_Handler (Supervisor Call). This is done to make the QK-nano ports compatible with various "hypervisors" (such as mbed uVisor or Nordic SoftDevice), which use the SVC exception. This release contains the updated QK-nano ports to ARM Cortex-M for all supported compilers: ARM-Keil, GNU-ARM, IAR EWARM, and TI-CCS-ARM.
Changes in detail:
1. Modified the ARM Cortex-M QK-nano ports to not use the SVC_Handler.
2. Modified the GNU-ARM ports of QK for ARM Cortex-M, to use the __ARM_ARCH macro to distinguish among different architectures (ARCHv6 vs ARCHv7).
3. Added error directives to source files from different built-in kernels (QV and QK) to generate meaningful error messages when these files are mixed in one project. For example, a project based on QV will report errors when source files for QK-nano are included in it.
4. Updated CMSIS from 4.2 to 4.3 in qpn/3rd-party/CMSIS
@section qpn_5_5_1 Version 5.5.1, 2015-10-06
This release adds state machine operations for implementing the shallow history mechanism. The operations are called QMsm_childStateObj() and QHsm_childState(), for QMsm and QHsm classes, respectively, because they compute a child state of a given parent, such that the child belongs to the same state hierarchy as the current state.
This release also improves the AAPCS compliance of the ARM Cortex-M port to the QK preemptive kernel. Specifically, the PendSV handler in assembly did not always maintain the 8-byte stack alignment, which is required by AAPCS. This version corrects the stack misalignment in the qk_port.s files for all supported ARM compilers (ARM-Keil, GNU, IAR, and TI CCS). All these ports should also be ready for ARM Cortex-M7.
Also, this release adds support for the TI CCS ARM compiler. Specifically, a new ARM Cortex-M ports have been added (in directories `qpn\ports\arm-cm\qk\ti\` and `qpn\ports\arm-cm\qk\ti\`) and TI CCS example projects have been provided (in directories `qpn\examples\arm-cm\dpp_ek-tm4c123gxl\qk\ti\` and `qpn\examples\arm-cm\dpp_ek-tm4c123gxl\qv\ti\`).
Changes in detail:
1. Added the new prototypes QMsm_childStateObj() and QHsm_childState() to qepn.h
2. Added implementation of QMsm_childStateObj() and QHsm_childState() to qepn.c
3. Modified the qk_port.s assembly implementation for all supported ARM Cortex-M toolsets (ARM-Keil, GNU, IAR, and TI CCS)
4. Added QP-nano Cortex-M port to TI CCS.
5. Added CCS example projects in `qpn\ports\arm-cm\qk\ti\` and `qpn\ports\arm-cm\qk\ti\
@section qpn_5_4_2 Version 5.4.2, 2015-06-07
The main focus of this release is to improve the support for "dual targeting" of QP-nano applications, which is developing of deeply embedded code as much as possible on the desktop OS, such as Windows. Experience shows that "dual targeting" dramatically improves productivity of embedded systems developers, perhaps more than any other technique.
This release makes it possible to use exactly the **same** application code, main function, and the Board Support Package interface (bsp.h) on both deeply embedded target and on Windows. The only differences between these targets can be completely encapsulated in the Board Support Package implementation (bsp.c).
The support for "dual targeting" in this QP-nano release works both for Win32 console and Win32 GUI applications. The Win32-GUI support enables developers to easily emulate the front-panels of the embedded devices, with LCD-screens (graphical and segmented), LEDs, buttons, switches, sliders, etc.
Changes in detail:
1. Modified the QP-nano port to Windows (@ref win32-qv) so that it supports both Win32 console and Win32-GUI applications. The newly introduced pre-processor #WIN32_GUI macro is now required to use the Win32-GUI facilities.
2. Added portable "safe" macros from `<stdio.h>` and `<string.h>` to the QP-nano port to Windows. These macros encapsulate the differences between Microsoft Visual C++ and other compilers (such as MinGW).
3. Simplified the structure of the QP-nano Windows port by eliminating one level of directories for the compilers used. Both VC++ and MinGW builds can now be run in the same port directory.
4. Modified the QF_stop() function in the QP-nano port to @ref win32-qv, so that it unblocks the QV event-loop and thus lets the application terminate.
5. Modified all examples for Windows to use the new port structure.
6. Improved all Makefiles (for the MinGW toolset) in all Windows examples, to make them easier to adapt to custom applications, both Win32 console and Win32 GUI.
7. Moved several examples from the `examples/win32/` and examples/win32-qv directories to `examples/arm-cm/` directory with native embedded examples for ARM Cortex-M. This co-location of the Win32 emulation with the embedded code running on the actual board demonstrates better the "dual targeting" development approach.
8. Made the ::QActiveCB (::QActive Control Block) to the QP-nano backwards-compatibility layer as deprecated. Instead, the newer QP-nano applications should use ::QMActiveCB.
9. Updated all Windows examples to the latest QP API by compiling the code with the macro #QP_API_VERSION set to 9999 (latest API without backwards compatibility)
@section qpn_5_4_0 Version 5.4.0, 2015-05-31
This release changes the basic philosophy of packaging and distributing the QP-nano framework by **combining** the "QP-nano Baseline Code" with all currently available "QP-nano Development Kits" (QDK-nano). This is done to eliminate any potential mistakes in downloading and installing separate pieces of code.
This release also changes the active object class hierarchy so that ::QMActive is now more fundamental and is the base class for ::QActive. (Previously ::QMActive was a subclass of ::QActive). The newly added documentation section about @ref classes "QP-nano Design" shows the current class hierarchy.
@note
Because the types ::QMActive and ::QActive are equivalent in QP-nano, this change has minimal impact on the applications, but it is now more correct to use ::QMActive as the base class for all "opaque" active object pointers.
Additionally, this release alignes the QP-nano framework better with the rest of the QP framework family (QP/C and QP/C++), so that fewer changes are needed to move applications between QP-nano and QP/C.
Finally, this release adds periodic time events (timers) to QP-nano. The feature is demonstrated by many provided examples (e.g., "Blinky", "Fly 'n' Shoot" game, PELICAN crossing).
The aforementioned changes have also the following ripple effects:
1. The structure of the QP-nano ports has been modified to match QP/C and to avoid repetitions. The QP-nano application no longer need to provide and #include the complete port `qpn_port.h` header file, which is now deprecated. Insted QP-nano application code needs to #include the <span class="img file_h">qpn.h</span> (QP-nano API) header file, which also now contains the QP-nano backwards-compatibility layer.
2. The application is now only responsible for providing the <span class="img file_h"><a href="qpn__conf_8h.html"><strong>qpn_conf.h</strong></a></span> file to set up the basic configuration for QP-nano. Examples of the `qpn_config.h` configurations are provided in all supplied QP-nano examples.
3. The actual port (e.g., the interrupt disabling policy for tasks and interrupts, interrupt entry/exit code, etc.) is included from the <span class="img folder">@ref ports</span> folder. This <span class="img folder">@ref ports</span> folder has been reorganized to contain all currently available QP-nano ports. The ports are organized into two categories: @ref ports_native "native QP-nano ports" ("bare-metal") and @ref ports_os "ports to big operating systems" (Windows and Linux).(**NOTE**: the ports are now documented in the this <strong>QP-nano Reference Manual</strong>. Each port sub-directory contains a <span class="img qp_link">README</span> link to the corresponding page in the online documentation)
4. Expanded the QP-nano time events (timers) with the ability to fire periodically. The feature is controlled by the preprocessor switch #QF_TIMEEVT_PERIODIC. When this macro is defined (in the `qpn_config.h` header file), the signature of the QActive_armX() function contains one more `interval` parameter. The `interval` parameter allows you to specify the interval of the periodic timeout. If the `interval` is zero, the time event is one-shot.
5. It is no longer necessary to define the **QPN environment variable** to build the QP-nano examples. All directories and files referenced by example projects are **relative** to the project folder. This change reflects the fact that most development tools add source files to the project using relative paths.
6. The QP-nano <span class="img folder">@ref exa</span> folder has been reorganized to reduce the repetitions and contains all currently available QP-nano examples. The folder includes four categories of examples: @ref exa_native "native QP-nano examples" ("bare-metal") and @ref exa_os "examples for big operating systems" (Windows and Linux). The <span class="img folder">examples</span> folder has been expanded to contain all currently available QP-nano examples, many of them are new in this release. (**NOTE**: the currently available examples are now documented in the <strong>QP-nano Reference Manual</strong>. Each example sub-directory contains a <span class="img qp_link">README</span> link to the corresponding page in the online documentation)
7. A new <span class="img folder">3rd_party</span> folder created to contain the Third-Party code used in the QP-nano ports and examples, such as MCU register files, low-level startup code, device drivers, etc. The <span class="img folder">3rd_party</span> folder avoids the need to repeat such code in every project. Also, the separation of the Third-Party components helps to clearly indicate code that comes from various sources, and to which Quantum Leaps, LLC expressly makes **no claims of ownership**. The Third-Party software components included in this "3rd_party" folder are licensed under a variety of different licensing terms that are defined by the respective owners of this software and are spelled out in the README.txt or LICENSE.txt files included in the respective sub-folders.
8. This release also comes with the much expanded online <strong>QP-nano Reference Manual</strong>, which is cross-linked with the ports and examples.
Changes in detail:
1. Renamed the "Vanilla" scheduler to the @ref comp_qv "QV-nano cooperative kernel" for symmetry with the @ref comp_qk "QK-nano preemptive kernel". Renamed QF_onIdle() callback to QV_onIdle().
2. Removed class ::QFsm (which is now deprecated). Legacy state machines coded in the "QFsm-style" will continue to work, but will use the ::QHsm implementation internally. There is no longer any efficiency advantage in using the "QFsm-style" state machines.
3. Updated @ref exa_arm-cm "ARM Cortex-M examples" and provided new examples for NXP mbed-LPC1768, and STM32 NUCLEO-L053R8, and NUCLEO-L152RE boards. All examples now use the latest CMSIS (V4.3.0). All ARM Cortex-M exampels are provided for the ARM-KEIL, GNU-ARM, and IAR-ARM toolsets.
4. Added the native @ref arm7-9 "port" and @ref exa_arm7-9 "examples" to the @ref arm7-9 "classic ARM7/9" with AT91SAM7S-EK board and the IAR-ARM toolset.
5. Added the native @ref avr "port" and @ref exa_avr "examples" to the AVR (AVRmega) with GNU-AVR and IAR-AVR toolsets. The @ref exa_avr "examples" are provided for the Arduino-UNO board.
6. Added the native @ref msp430 "port" and @ref exa_msp430 "examples" to MSP430 with TI CCS-430 and IAR-430 toolsets. The @ref exa_msp430 "examples" are provided for the MSP430 LauchPad boards (the MSP-EXP430G2 and MSP-EXP430F5529LP for the "classic" MSP430 and "extened" MSP430X, respectively).
7. Updated @ref win32-qv "port to Win32-QV" (Windows with cooperative "Vanilla" scheduler, previously known as Win32-1T). Modified the port to apply a "fudge factor" in over-sizing QP-nano event queues and event pools, to minimize the risk of overflowing queues/pools due to non-deterministic Windows behavior.
8. Renamed the POSIX port to @ref posix-qv "POSIX-QV" (POSIX with cooperative "Vanilla" scheduler). Modified the port to apply a "fudge factor" in over-sizing QP-nano event queues and event pools, to minimize the risk of overflowing queues/pools due to non-deterministic behavior under POSIX.
@section qpn_5_3_0 Version 5.3.0, 2014-04-18
This release adds the "transition to history" (deep history) feature to
both QHsm and QMsm state machines and their subclasses. This QP-nano
release matches the new QM modeling tool Version 3.1.0, which now
supports the "transition to history" connector and the corresponding
code generation for transitions to history.
@note QP-nano 5.3.0 breaks backwards-compatibility with QP-nano
applications developed for QP-nano 4.x and 5.x. However, the update to
QP-nano 5.3.0 typically requires only to add #include <stdbool.h> and
#include "qassert.h" to the qpn_port.h header file in the application
directory. Any QM models created for the previous QP-nano versions
remain fully compatible with QP-nano 5.3.0, but you need to re-generate
the code with QM 3.1.0.
This release comes with new and updated QDKs for MSP430. Specifically,
new QDKs have been added for the MSP-EXP430G2 LaunchPad as well as the
MSP-EXP420F5529LP LauchPad. Also, the QDKs for MSP430 with the TI Code
Composer Studio are now part of the baseline QP-nano distribution.
This release also goes several steps towards compliance with the new
MISRA-C:2012 rules. For example, unused tag declarations have been
removed (MISRA-C:2012 Rule 2.4), the C99 standard Boolean data type in
<stdbool.h> has been added instead of uint8_t for stricter type
analysis, and the C99 data types uint_fast8_t and uint_fast16_t are used
instead of the non-standard uint_t.
Finally, this QP-nano release brings deep changes in the source code
comments and the doxygen documentation generated from the source code.
All comments have now more consistent structure, and every function is
now documented in the implementation file (.c file), whereas the
interface (.h files) contain only the brief descriptions of the
functions. This re-structuring of documentation is performed as part of
the validation and verification effort that has begun to provide a
certification package for QP-nano for safety standards, such as IEC
61508 and ISO 62304 (FDA 510(k)).
Changes in detail:
1. Moved detailed documentation of functions from the header files (.h)
to implementation files (.c).
2. Added macros: Q_TRAN_HIST(), QM_TRAN_HIST(), and QM_TRAN_EP(), to
"qepn.h"
3. Added attributes entryAction and initAction to the QMState struct in
"qepn.h" (needed for transition to history).
4. Changed return type to bool in virtual functions QMsmVtbl.post() and
QMsmVtbl.postISR() as well as the implementations: QActive_postX_(), and
QActive_postXISR_().
5. In qepn.h, changed the QState return type from action/state handler
functions to uint_fast8_t.
6. In qfn.h, changed the type of QActive attributes prio, head, tail,
and nUsed to uint_fast8_t.
7. In qfn.h, changed the type of of QTimeEvtCtr, as well of the tickRate
argument in QF_tickXISR(), QActive_armX(), and QActive_disarmX() to
uint_fast8_t.
8. Changed the return type from QK_schedPrio_() (priority) as well as
the p argument in QK_sched_() to uint_fast8_t
9. Added new QDKs-nano/IAR for MSP-EXP430G2 LaunchPad
10. Added new QDKs-nano/IAR for MSP-EXP420F5529LP LauchPad LaunchPad
11. Added new QDKs-nano/CCS for MSP-EXP430G2 LaunchPad
12. Added new QDKs-nano/CCS for MSP-EXP420F5529LP LauchPad LaunchPad
@section qpn_5_2_0 Version 5.2.0, 2013-12-30
This release matches the new QM 3.0.0, for which it provides model
examples based on the new QMsm/QMActive classes. This, in turn
demonstrates the new state machine code generation that QM3 was
specifically designed to do.
This release also provides consistent API for late-binding ("virtual"
functions) introduced in QP-nano 5.0.0, as opposed to using regular
linking (early-binding) for direct function calls, such as
QHsm_dispatch(). A clearly separated API compatibility layer is
provided, whereas you can configure a level of backwards compatibility
by means of the #QP_API_Version macro. This facilitates migrating
existing QP applications to the newer API.
An cyclomatic complexity (McCabe V(G)) analysis of this Version has been
performed and the maximum V(G) complexity per function has been reduced
to 15 by breaking up the QHsm_dispatch_() function. The code metrics
report, including cyclomatic complexity by function as well as other
standard code metrics (e.g., lines of code), is now included in the
"QP-nano Reference Manual", see
https://www.state-machine.com/qpn/metrics.html
Finally, this release demonstrates safer stack allocation and safer
exception handlers in all ARM Cortex-M examples. The techniques are
described in the Embedded.com article "Are We Shooting Ourselves in the
Foot with Stack Overflow?".
Changes in detail:
1. In file qepn.h renamed the implementation functions, such as
QHsm_init() and QHsm_dispatch() to QHsm_init_() and QHsm_dispatch_()
(note the underscore, which means that the functions should not be
called directly by the application code). The only correct way of
calling the functions is through the macros QMSM_INIT() and
QMSM_DISPATCH(), respectively. The latter macros implement late-binding
("virtual" functions in C).
2. In file qfn.h renamed the implementation functions, such as
QActive_postX() and QActive_postXISR() to QActive_postX_(), and
QActive_postXISR_, respectively (note the underscore, which means that
the functions should not be called directly by the application code).
The only correct way of calling the functions is through the macros
QACTIVE_POST(), QACTIVE_POST_X(), QACTIVE_POST_ISR() and
QACTIVE_POST_X_ISR(). The latter macros implement late-binding
("virtual" functions in C).
3. for backwards compatibility, in files qepn.h and qfn.h defined "API
Compatibility Layer", which is controlled by the macro #QP_API_VERSION.
For example, specifying QP_API_VERSION=500 chooses API compatible with
QP Version 5.0.0 or newer, but excludes APIs that became deprecated in
the earlier versions. If the macro #QP_API_Version is not defined by the
user (typically on the command line for the compiler), the default value
of 0 is assumed. This default means maximum backwards compatibility
(from Version 0.0.0). On the other hand, higher values of
#QP_API_Version mean less backwards compatibility. For example
QP_API_VERSION=9999 will specify compatibility only with the latest
Version of QP-nano. The API Compatibility Layer for QP_API_Version < 500
provides macros: QHsm_init(), QHsm_dispatch(), QActive_post() and
QActive_postISR(). These macros resolve to QMSM_INIT() and QMSM_DISPATCH(),
QACTIVE_POST() and QACTIVE_POST_ISR() respectively, so that calls based
on the older API also use late-binging.
4. In file qepn.c, broken up the function QHsm_dispatch() into two
functions QHsm_dispatch_() and QHsm_tran_(). This has reduced the
cyclomatic complexity from 25 for the original function, to 11 and 15
for QHsm_dispatch_() and QHsm_tran_(), respectively.
5. Updated all examples for ARM Cortex-M to use safer stack allocation
and safer exception handlers in all ARM Cortex-M examples, as described
in the Embedded.com article "Are We Shooting Ourselves in the Foot with
Stack Overflow?".
@section qpn_5_1_1 Version 5.1.1, 2013-10-15
@note QP-nano 5.1.1 remains backwards-compatible with the existing
QP-nano 4.x applications, except QP-nano 5.1.x requires changing the
interrupt priority setting in the existing ARM Cortex-M applications.
Specifically, you need to set the interrupt priorities equal or lower
than <b>QF_AWARE_ISR_CMSIS_PRI</b> constant provided in the qfn_port.h
header file.
The main purpose of this milestone QP-nano release is to enable the QM
modeling tool to generate a new type of state machine code (requires QM
Version 3.0.0, which is still in development as of this writing).
This new type of state machine implementation in QP-nano 5 is based on
the new QMsm class, which takes advantage of the QM tool as an advanced
"state machine compiler". QM can perform optimizations that were not
possible with the C preprocessor alone. Specifically, the QM can easily
determine the LCA (Least-Common-Ancestor) state for every transition and
it can generate the complete transition-sequences (sequences of
exit/entry/initial actions) at code-generation time. The resulting code
can be still highly human-readable, but it will no longer be
human-maintainable. The lab tests indicate that the new "housekeeping"
code for executing hierarchical state machines can be about twice as
fast as the previous code based on the QHsm class. Additionally, the new
code requires less run-time support (smaller event processor) and uses
70% less of stack space in the call to the QMsm_dispatch() operation
than QHsm_dispatch().
The next big feature introduced in QP-nano 5 is polymorphism ("virtual"
functions) for basic operations, such as state machine init() and
dispatch() and active object post(), and postISR() operations. Making
theses functions "virtual" means that all these operations can be
re-defined in sub-classes of state machines and active objects. This, in
turn, allows a single application to use a mix of state machine classes
derived from the new QMsm base class with state machines derived from
the QHsm base class, each one using a different state machine
implementation strategy. Additionally, the virtual post() operation
could be very useful for implementing various Proxy active objects
(e.g., for active object event posting across networks).
Another big feature introduced in QP-nano 5 are the multiple,
independent system clock tick rates for time events. The number of
system tick rates can be now configured in the QP-nano ports. For
example, a digital watch can use a "fast" clock tick rate of 100Hz and a
"slow" clock tick rate of only 1Hz. These clock tick rates can be
managed independently, so for example, the fast clock tick rate can be
shut down in the absence of time events assigned to this rate. This
feature allows the applications to implement sophisticated power-saving
policies.
As yet another important feature, QP-nano adds a new "extended" API for
non-asserting event allocation and posting. This feature is intended for
situations, where an application is hammered with external events that
at times arrive too fast for processing, but that can be ignored under
the overload conditions. In those cases firing an assertion inside the
framework is undesirable. The non-asserting API allows a designer to
request a safety-margin when allocating or posting an event. The event
is not allocated/posted if the safety margin cannot be satisfied at the
time of the call. On the other hand, the safety margin allows the
application to still use the regular (asserting) event allocation and
posting, because the event pools and event queues are guaranteed to
maintain a minimal margin for safe operation.
Finally, QP-nano 5.1.0 never completely disables interrupts in the ARM
Cortex-M3/M4 cores, even inside the critical sections. On Cortex-M3/M4
(ARMv7-M architectures), the QP port disables interrupts selectively
using the BASEPRI register. (NOTE: The BASEPRI register is not
implemented in the ARMv6-M architecture (Cortex-M0/M0+), so
Cortex-M0/M0+ need to use the PRIMASK register to disable interrupts
globally).
This new policy of disabling interrupts divides interrupts into
"kernel-unaware" interrupts, which are never disabled, and
"kernel-aware" interrupts, which are disabled in the QP critical
sections. Only "kernel-aware" interrupts are allowed to call QP
services. "Kernel-unaware" interrupts are *NOT* allowed to call any QP
services and they can communicate with QP only by triggering a
"kernel-aware" interrupt (which can post or publish events).
As mentioned above, all QP ports to ARM Cortex-M included in the QP
5.1.x Baseline Code provide the constant QF_AWARE_ISR_CMSIS_PRI, which
must be used to offset the "kernel-aware" interrupt priorities.
All example projects for ARM Cortex-M included in the QP-nano 5.1.x
Baseline Code demonstrate the recommended way of assigning interrupt
priorities in your applications. The initialization consist of two steps:
1. you enumerate the "kernel-unaware" and "kernel-aware" interrupt
priorities (whereas you offset the "kernel-aware" priorities by the
constant QF_AWARE_ISR_CMSIS_PRI) and
2. you assign the priorities to *ALL* interrupts by calling the
NVIC_SetPriority() CMSIS function.
****
NOTE: Leaving the interrupt priority at the default value of zero
(the highest priority) is most likely incorrect, because the
"kernel-unaware" interrupts cannot call any QP services.
****
For more information, please read the short Application Note "Setting
ARM Cortex-M Interrupt Priorities in QP 5.1" available at:
https://www.state-machine.com/arm/AN_ARM-Cortex-M_Interrupt-Priorities.pdf.
The following list details the changes:
1. Added the new QMsm "class" to qepn.h. Changed the inheritance tree by
deriving QHsm and QFsm from the QMsm base class. Added virtual table
structures for QMsm, QHsm, and QFsm (polymorphism).
- added macro QMSM_INIT() to polymorphically call the state
machine initialization implementation in the QMsm base class and
all subclasses.
- added macro QMSM_DISPATCH() to polymorphically call the state
machine event dispatching implementation in the QMsm base class
and all subclasses.
2. Added the new "QMActive" "class" to qfn.h. Extended the inheritance
tree to derive QMActive from QActive. Added virtual table structures for
QMActive and QActvie (polymorphism).
- added macro QACTIVE_POST() to polymorphically call the direct
event posting to an active object.
- added macro QACTIVE_POST_ISR() to polymorphically call the
postISR (posting from interrupts) to an active object.
3. Added the multiple system clock tick rates feature in qfn.h:
- added new configuration macro QF_MAX_TICK_RATE, which specifies
the number of clock tick rates. This macro is to be defined in
the QF ports (in the qpn_port.h header file). If the macro is
undefined, the default value is 1 (one clock tick rate).
- renamed and re-implemented the QF_tickISR() function as the
"extended" QF_tickXISR() function with the argument 'tickRate' for
processing time events allocated to different clock rates. The
application must call QF_tickXISR(0), QF_tickXISR(1), ... at the
specified tick rates from ISRs or *tasks*.
- renamed and re-implemented the internal function QTimeEvt_arm_()
to a public function QActive_armX() for arming time events
initialized with the "extended" constructor. The QActive_armX()
function is the new recommended API for arming time events, both
one-shot and periodic.
- re-implemented QActive_disarm().
- extended QF_timerSetX_ to an array of [QF_MAX_TICK_RATE], so that
every rate can be checked independently.
4. Added the new non-asserting API to qf.h:
- added functions QActive_postX() and QActive_postXISR() to post an
event to the given active object. The functions do not post the
event if the target event queue has less free slots than the
specified margin. The functions assert if the margin is zero and
the event can't be posted.
5. Changed the structure of the ARM Cortex-M ports
- renamed the sub-directory for ARM Cortex-M ports and examples
from "arm-cortex" to "arm-cm". This is done to avoid confusion
with other ARM Cortex variants, such as Cortex-A/R, which very
different from Cortex-M.
- removed the CMSIS (Cortex Microcontroller Software Interface
Standard) directories from the Cortex-M examples and moved it to
the common location in the %QPN%/ports/arm-cm/cmsis/ directory.
Upgraded the CMSIS to the latest Version 3.20.
- added the ARM Cortex-M ports and examples with Keil/ARM MDK to
the QP Baseline Code.
- upgraded ARM Cortex-M ports with IAR to the latest IAR EWARM 6.60
- upgraded ARM Cortex-M ports with Sourcery CodeBench to the latest
Version 2013.05-53.
9. Added the requested simple "Blinky" example for Windows and ARM
Cortex-M (with the GNU, IAR, and Keil toolsets).
- Added "Getting Started with QP-nano" guide based on the Blinky
example.
10. Modified the application examples with PC-Lint
(qpn/examples/arm-cm/gnu/dpp-qk_ek-lm3s811-lint and
qpn/examples/arm-cm/iar/dpp-qk_ek-lm3s811-lint). Updated lint files for
the latest PC-Lint
11. Ported all state pattern examples to Win32/MinGW. That way, all
these examples can be run and modified directly on Windows, without
going back to DOS.
12. Updated the Doxygen documentation (QP-nano Reference Manual)
- updated the QP-nano tutorial
- updated and added documentation and code samples
- added search box and tree-view panel to the HTML documentation
@section qpn_4_5_04 Version 4.5.04, 2013-02-09
The main purpose of this release is adding support for the ARM Cortex-M4F
processors with the hardware Floating-Point Unit (FPU). The QP-nano ports
to Cortex-M4F take full advantage of the "lazy stacking" feature of the
FPU registers, and by doing so offer the most efficient preemptive
multitasking on this processor.
Changes in detail:
1. Added ports and examples for ARM Cortex-M4F with the EK-LM4F120XL
board (Stellaris Launchpad).
2. Added the macro QF_LOG2(), which can be re-implemented in the QP-nano
ports, if the CPU supports special instructions, such as CLZ (count leading
zeros in Cortex-M3/M4). If the macro is not defined in the QP port, the
default implementation uses a lookup table.
3. Updated all ARM Cortex-M ports and examples to the latest IAR EWARM
6.50 and Sourcery CodeBench 2012.09-85.
4. Updated App Notes "QP and ARM Cortex-M with IAR" and "QP and ARM
Cortex-M with GNU".
5. Updated the PC-Lint support files (`lib-qpn.lnt`, `au-misra2.lnt`)
to the latest PC-Lint 9.00j.
6. Updated the Application Note: "QP-nano MISRA-C:2004 Compliance Matrix".
7. Spell-checked the comments in all QP-nano source files and removed
several typos.
8. Removed the Qt ports and examples from the QP-nano Baseline Code and
@note QP-nano Version 4.5.04 preserves full compatibility with QM 2.2.03
and all existing QDKs for QP-nano 4.5.xx.
@section qpn_4_5_03 Version 4.5.03, 2012-11-29
This release changes the directory structure of QP-nano examples
for various operating systems, such as POSIX (Linux, BSD, etc.),
Win32 (Windows), Qt, etc. The OS examples are moved from the
exampels/80x86/ directory one level up to examples/.
@section qpn_4_5_02 Version 4.5.02, 2012-08-17
The main purpose of this release is providing QM models in most
examples and better, more comprehensive support for (rapid)
prototyping of embedded QP applications on the desktop with the
Win32 API and with Qt. Among others, this release adds a complete
toolkit for creating realistic embedded front panels with pure
Win32-GUI API and free Visual C++ Express and ResEdit. An extensive
Application Note "QP and Win32" is included in this release.
This QP relase adds QM models, created with the new QM 2.2.01,
to most of the examples. The code generated by this new QM version
complies with MISRA-C:2004 rules.
This release adds the variable QF_timerSet_ and bookkeeping
around it, so that the state of all timeouts in the system can
be determined quickly and efficiently. This feature is for power-
sensitive applications, where the system clock tick interrupt
needs to be turned off. One of the criteria to entering such a
sleep mode is that all timeout events are disarmed, that is,
when (QF_timerSet_ == (uint8_t)0).
Changes in detail:
1. Added QF_timerSet_ declaration to qfn.h and setting/clearing
this bitmask into qfn.c and qfn_init.c. This feature is controled
by the configuration macro Q_TIMERSET.
2. Modified QP-nano port to Win32 and used the free Visual C++ Express
2010 with Platform SDK rather than Visual C++ Pro 2008. Provided a
completely revised App Note "QP and Win32".
3. Renamed the port directory qt_1t/ to qt/.
4. Added QM models to most examples and used the automatically
generated code from the models instead of the hand-written code.
5. Added .ui files to the Qt examples for generating UIs
graphically with the Qt Designer tool. Revised and updated the
App Note "QP and Qt".
6. Removed definition of the macro QF_FSM_ACTIVE from qpn_port.h
files in <qpn>/examples/80x86/watcom/dpp and
<qpn>/examples/80x86/watcom/game. This configuration conflicted
with the actual definition of the active objects, which used
*hierarchical* state machines, not the "flat" state machines.
@section qpn_4_5_01 Version 4.5.01, 2012-06-14
The main purpose of this minor release is providing improved
MISRA-compliant state machine implementation. Specifically, a new
macro Q_UNHANDLED() has been added for a situation when a guard
condition evaluates to FALSE, but the state model does not prescribe
the explicit [else] case for this guard. In this case, the state
handler can return Q_UNHANDLED(), which will cause the QEP event
processor to propagate the event to the superstate, which is what
UML semantics prescribes.
NOTE: These change to the QEP-nano event processor is completely
backwards-compatible. All state hander functions coded the old
way will continue to handle the guard conditions correctly and
in accordance with the UML specification. The new Q_UNHANDLED()
macro is necessary only for MISRA-compliant state handler coding,
which will be applied in the upcoming release of the QM modeling
and code generation tool.
Changes in detail:
1. Added macro Q_UNHANDLED() and return value Q_RET_UNHANDLED in
qepn.h.
2. Modified qepn.c to handle the Q_RET_UNHANDLED return value.
3. Updated the QP-nano MISRA-C:2004 compliance matrix to
include the new MISRA-compliant way of coding guard conditions.
4. Updated the IAR ARM compiler used in the ARM Cortex-M examples
to the latest Version IAR EWARM 6.40.
5. Modified the Qt port not to define the QPApp::onClockTick()
slot, but instead to allow defining this slot in the BSP of the
application.
@section qpn_4_5_00 Version 4.5.00, 2012-05-30
The main pupose of this relase is to improve host-based development of
QP-nano applications, which is critical for Test-Driven Development (TDD).
Among others, this release provides integration between QP-nano and the
popular Qt GUI framework, which allows developers to easily build host-
based simulations of the embedded systems with the realistic user
interfaces.
This realase also simplifies implementing transitions to history, which
is a preparation to providing this feature in the QM modeling tool.
Changes in detail:
1. Renamed the event class from QEvent to QEvt to avoid a name conflict
with the Qt framework.
NOTE: To minimize impact of this change on the existing QP-nano ports
and applications, the name QEvent is provided as well, but this can be
suppressed by defining the configuration macro Q_NQEVENT in qep_port.h.
2. Added return value to QF_run() to allow transfer of the exit
status to the destop operating systems.
NOTE: This modification haves impact on most QP-nano ports, because
the QF_run() function must now return a int16_t value.
3. Added member 'temp' to the QHsm and QFsm base classes to prevent
clobbering the current state (the 'state' member) during transitons.
This change allows keeping the current state unchanged during the
entire transition chain, which in turn allows easy and generic access
to the state information to store the state history in the exit
actions from states. Additional bonus of this re-design is the
opportunity of testing for stable state configuration in assertions
added to the qepn.c file.
4. Added the QHsm_state() and QFsm_state() accessor macros.
5. Modified the "Transition to History" pattern implementation to
use the simplified technique of obtaining the current state in the
exit action from the superstate rather than all the exit actions from
the substates. Modified the "State-Local Storage" (SLS) pattern as
well, because it was using the transition to history constructs.
6. Modified the QP-nano port to Win32 (both the MinGW and VC2008).
7. Modified the QP-nano port to POSIX.
8. Added QP port to Qt (Qt with one thread) and two example
applications (DPP and PELICAN crossing).
9. Added GNU compiler option -pthread to QP ports for POSIX with
P-threads, including QP ports and examples for Linux and Mac OS X.
@section qpn_4_4_00 Version 4.4.00, 2012-03-03
The main pupose of this relase is MISRA-C:2004 compliance, strong-type
checking compliance, update of PC-Lint option files and tests, and
general cleanup.
1. For commonality with the QP/C and QP/C++ frameworks renamed macros
QF_INT_LOCK/QF_INT_UNLOCK to QF_INT_DISABLE/QF_INT_ENABLE, respectively.
Also renamed macros QF_INT_KEY_TYPE/QF_ISR_LOCK/QF_ISR_UNLOCK to
QF_ISR_STAT_TYPE/QF_ISR_DISABLE/QF_ISR_RESTORE, respectively.
NOTE: This modifications have impact on most QP-nano ports. However,
the qfn.h header file contains definitions of the new macros in terms
of the old ones. This provies backwards comatibility of the existing
QP-nano ports.
2. Added the PC-Lint option files std.lnt and lib-qpn.lnt to the
qcn/include/ directory.
3. Cleaned the whole QP-nano code from lint comments. All PC-Lint options
have been moved to PC-Lint option files.
4. Modified QP-nano assertion macro Q_DEFINE_THIS_MODULE() to avoid
using the # operator (MISRA rule 19.13). This macro now requires the
argument enclosed in doble quotes "".
NOTE: This modification has impact on some QP-nano ports.
4. Added typedefs for char_t, int_t, float32_t, and float64_t to
event.h header file for compliance with MISRA-C:2004 rules 6.1 and 6.3.
5. Added macros Q_STATE_CAST() and Q_ACTIVE_CAST() to qep.h to
encapsulate deviation from MISRA-C rule 11.4.
6. Added macro Q_UINT2PTR_CAST() to encapsulate casting unsigned
integers to pointers, which deviates from MISRA-C rule 11.3. This
macro has been added for *application-level* code.
7. Updated ARM Cortex-M examples with the latest CMSIS v3.0, which
complies with more MISRA-C:2004 rules.
8. Added PELICAN examples for MISRA-C:2004 compliant applications (for
IAR-ARM and GNU-ARM).
9. Added testing of PC-Lint option files against the MISRA-C Exemplar
Suite.
10. Updated ARM-Cortex-M3 port with GNU to the latest Sourcery
CodeBench 2011.09-60.
11. Added documentation to QP-nano distribution in the directory
qpn/doc/, with the following Application notes: "QP-nano MISRA-C:2004
Compliance Matrix" and "Quantum Leaps Coding Standard",
@section qpn_4_3_00 Version 4.3.00, 2011-10-31
1. This release changes the partitioning of the QK-nano scheduler.
Specifically, the QK-nano scheduler is now divided between two
functions QK_schedPrio_() and QK_sched_(), to calculate the highest-
priority task ready to run and to perform scheduling, respectively.
The function QK_schedPrio_() is useful to determine if scheduling
is even necessary.
2. Reduced the interrupt latency of the QK-nano kernel by breaking up
the critical section in the QK_sched_() into two pieces, just after
setting QK_currPrio_.
3. Modified the ARM Cortex-M port qkn_port.s to take advantage of the
new structure of the QK-nano scheduler. To reduce code duplications,
the QK-nano port file qkn_port.s has been placed in the directories:
qpn/ports/arm-cortex/qk/gnu/ for the GNU compiler and
qpn/ports/arm-cortex/qk/iar/ for the IAR compiler, respectively.
4. Moved the Win32 and POSIX emulation of QP-nano from the directory
qpn/emulation/ to qpn/ports/win32/ and qpn/ports/posix/, respectively.
5. Renamed the function QF_tick() to QF_tickISR() to clearly notify
the user that this function is callable from ISR only. For backwards
compatibility, the macro QF_tick() is defined to QF_tickISR().
6. Modified QF_tickISR(), QActive_postISR(), QActive_post(), and
QK_sched_() to use stack-based pointer to QActiveCB, which avoids
re-computation of the pointer on-the-fly in the loop. According to the
feature request #3403079, this significantly speeds up the code for
8-bit PIC micros.
7. Upgraded the examples for ARM Cortex with IAR EWARM to the
latest IAR EWARM Version 6.30.
8. Upgraded the examples for ARM Cortex with GNU (CodeSourcery) to the
latest Sourcery CodeBench 2011.07-60.
@section qpn_4_2_04 Version 4.2.04, 2011-09-24
The main pupose of this relase is to provide a bug fix for the QK port
to ARM Cortex processors. The bug fix addresses a very rare and
undocumented behavior of late-arrival of an interrupt while entering
the PendSV exception. In this case the PENDSVSET bit in the NVIC-ICSR
register is *not* cleared when finally PendSV is entered, so the
PendSV exception is entered in a *different* state when it is entered
via the late-arrival mechanism versus the normal activation of the
exception through tail-chaining. The consequence of this undocumented
and inconsistent hardware behavior, PendSV could be re-entered again
before the SVCall exception cleans up the stack. The bug fix is
implemented in the qk_port.s file (in QP-nano this file is replicated
in every example for QK-nano) and consists of clearing the PENDSVSET
bit programmatically inside PendSV_Handler.
@section qpc_4_2_02 Version 4.2.02, 2011-09-08
The main pupose of this relase is to repackage the default QP-nano
distribution to contain the single root directory qpn/ in the
archive. That way, unziping the archive will produce only one
directory (qpn/), which can be then changed by the user.
@section qpn_4_2_01 Version 4.2.01, 2011-08-13
1. Modified file qassert.h to add assertion macros #Q_ASSERT_ID,
#Q_REQUIRE_ID, #Q_ENSURE_ID, #Q_INVARIANT_ID, and #Q_ERROR_ID,
which are better suited for unit testig, because they avoid the
volatility of line numbers for indentifying assertions.
2. Modified the make files and project files to use the environment
variable QPN instead of relying on the relative path to the QP-nano
framework.
3. Added QP-nano examples for Mac OS X on 80x86.
4. Upgraded the examples for ARM Cortex with IAR EWARM to the
latest IAR EWARM Version 6.20.
5. Upgraded the examples for MSP430 with IAR EW430 to the
latest IAR EW430 Version 5.30.
@section qpn_4_1_07 Version 4.1.07, 2011-02-28
The goal of this release is to improve the ease of experimenting with
QP-nano on the desktop. This release adds support for Windows (Win32)
and Linux to the QP-nano baseline code. Two most popular compilers for
Windows are supported: Microsoft Visual Studio and MinGW (GNU). The
support for Linux includes pre-built examples and makefiles compatible
with Eclipse.
The changes in detail are:
1. Added sub-directory qpn/emulation with emulation code for Windows
(win32) and POSIX (Linux, Mac OS X, etc.).
2. Added Win32 examples for Visual C++ 2008 (examples/80x86/win32/
vc2008/dpp and examples/80x86/win32/vc2008/qhsmtst). Visual Studio
soultions are provides for all build configurations.
3. Added Win32 examples for MinGW (examples/80x86/win32/mingw/dpp
and examples/80x86/win32/mingw/qhsmtst). Eclipse-compatible makefiles
are provided for all build configurations. NOTE: the Makefiles assume
that the MinGW/bin directory is added to the PATH.
4. Fixed a bug in file qfn.c, function QActive_postISR(). For special
rare combination of configuration macros the assertion was checked
before declaring an automatic variable QF_ISR_KEY_TYPE key. This
declaration has been moved to the top of the function.
5. Upgraded the examples for ARM Cortex with CodeSourcery to the
latest Sourcery G++ 2011.02-2.
@section qpn_4_1_06 Version 4.1.06, 2011-01-07
1. Made cosmetic improvements to the example QM model of the
"Fly 'n' Shoot" game.
2. Made improvements in make.bat files for building the examples for
DOS/Open Watcom to run better in DosBox on Linux.
3. Upgraded the examples for ARM Cortex with IAR to the latest
IAR EWARM Version 6.10.
4. Upgraded the examples for ARM Cortex with CodeSourcery to the
latest Sourcery G++ 2010.09-66.
@section qpn_4_1_05 Version 4.1.05 (Product) Nov 01, 2010
This release is adds examples for the QM (QP Modeler) graphical modeling
and code generation tool. The examples are based on the "Fly 'n' Shoot"
game described in the QP-nano Tutorial and in Chapter 1 of the PSiCC2 book.
Specifically, the directory qpn/examples/80x86/watcom/game-qm/
contains the "Fly 'n' Shoot" game model file "game.qm". This model, when
opened in the QM tool contains all state machine diagrams and generates
code into the subdirectory qm_code/. This code can then be built and
executed on any 80x86 machine (newer versions of Windows or Linux require
the DOSbox application, see http://www.dosbox.com).
The directory qpn/examples/arm-cortex/iar/game-ev-lm3s811-qm/
contains the Version of the game for the EV-LM3S811 ARM Cortex-M3 board.
This directory contains the model file "game.qm", which is actually
identical as the model in the DOS version. The LM3S811 Version needs to
be compiled with the IAR compiler and executed on the EV-LM3S811 board.
Additionally, the QP-nano baseline code has been slighlty modified for
better conformance to the MISRA C 2004 rules and the latest PC-Lint 9.x.
@section qpn_4_1_04 Version 4.1.04, 2010-03-16
This release is adds compatibility of all examples for DOS with the DOSBox
emulator (http://www.dosbox.com/) that recreates a MS-DOS compatible
environment on all versions of Windows, including 64-bit Windows that don't
run 16-bit DOS applications anymore.
Also, this release includes QP ports and examples for EV-LM3S811 board with
the GNU-based Code Sourcery G++ toolset. Support for Sourcery G++ provides
a very cost-effective option for developing QP applications for ARM Cortex
MCUs.
Finally, this release improves the Cortex Microcontroller Software Interface
Standard (CMSIS) for the whole family of the Stellaris LM3Sxxx MCUs. The
improvement extends the CMSIS from Sandstorm to Fury, DustDevil, and Tempest
Stellaris families.
@section qpn_4_1_03 Version 4.1.03, 2010-01-21
This release is concerned with the ARM Cortex ports and examples.
Specifically, this release contains the following improvements:
1. Unified source code for ARM Cortex-M3 and the new ARM Cortex-M0 cores,
including the code for the preemptive QK kernel.
2. Compliance with the Cortex Microcontroller Software Interface Standard
(CMSIS) in all ARM Cortex examples.
3. Backward-compatible support for the new LM3S811 EVAL Rev C board with
different OLED display than previous revisions. (NOTE: The OSRAM 96x16x1 OLED
used in REV A-B boards has been replaced RITEK 96x16x1 OLED used in Rev C.)
In the process of making the examples CMSIS-compliant, the dependency on the
Luminary Micro driver library (driverlib.a) has been completely removed.
Additionally, the screen saver of the "Fly 'n' Shoot" game has been improved
to periodically switch off the power of the OLED display, which better
protects the display from burn-in. The affected file is tunnel.c.
Finally, this release introduces the QP_Version macro, which identifies the QP
version. Otherwise, this maintenance release does not change the QP/C API in
any way, so the release has NO IMPACT on the QP/C applications except for the
ARM Cortex ports and applications.
@section qpn_4_1_02 Version 4.1.02, 2010-01-14
The purpose of this minor maintenance release is the change in the directory
structure for the ARM Cortex ports and examples. As new ARM Cortex cores are
becoming available, the old port name "cortex-m3" could be misleading, because
it actually applies to wider range of ARM Cortex cores. Consequently, all ARM
Cortex ports and examples are hosted in the directory tree called
"arm-cortex".
This maintenance release does not change the QP-nano API in any way, so the
release has NO IMPACT on the QP-nano applications except for the ARM Cortex
ports and applications.
@section qpn_4_1_01 Version 4.1.01, 2009-11-05
The main purpose of this release is to replace the Turbo C++ 1.01 toolset
with the Open Watcom C/C++ toolset, because Turbo C++ 1.01 is no longer
available for a free download. In contrast, Open Watcom is distributed under
an OSI-certified open source license, which permits free commercial and
non-commercial use. Open Watcom can be downloaded from www.openwatcom.org.
All 80x86 examples (vanilla and QK-nano) for Turbo C++ 1.01 have been replaced
with examples for Open Watcom. The make.bat scripts are provided to build the
examples.
In the process of converting the examples to Open Watcom a new SLS example
have been added to the standard QP-nano distribution. The SLS example located
in <qpn>/examples/80x86/watcom/sls/ shows the QP-nano implemenation of the
new State-Local Storage state design pattern.
@section qpn_4_1_00 Version 4.1.00, 2009-10-09
The main purpose of this release is to fix a bug in event posting, which
could cause corruption of the event signal. Such corruption could occur when
an event was posted to an empty event queue, in which case it was written
directly to the internal event stored in the state machine, bypassing the
ring-buffer. However, the signal of the internal event could also be changed
by the QEP-nano event processor during execution of transitions.
The bug fix is to always pass events through the ring buffer and never
overwrite the internal event during event posting (both from the task
level and from the ISR level). The update of the ring buffer always
occurs within a critical section and is safe from interruptions.
This bug fix also allows posting of events from the top-most initial
transitions of active objects during the initialization phase. Previously,
the execution of the top-most initial transition corrupted the signal of
the internal event.
The bug fix enables also self-posting of events from entry/exit actions
and internal initial transitions. Again, the QEP event processor corrupted
the internal signal.
This release also replaces the static variables 'p' (priority) and 'a'
(active object pointer) with automatic variables. This change results in
more efficient code, because the frequently used variables can be kept in
registers and do not need to be read/written from/to memory by each use.
Additionally, this release updates the QP-nano ARM Cortex-M3 examples for
the EK-LM3S811 board to the latest IAR EWARM 5.40. Due to the acquisition
of Liminary Micro by Texas Instruments the directory IAR structure for the
examples and drivers has changed and the QP-nano examples had to be changed
accordingly.
Finally, this release fixes a bug in the "Fly 'n' Shoot" game example for
QP-nano, which caused an assertion if the Ship was moved to the very top
of the Tunnel. This was due to the y-coordinate of the ship explosion
becomoming negative.
NOTE: This release does not change the QP-nano API, but all event queues
are effectively shortened by one event. Also it is no longer possible to
declare an active object without a ring buffer (zero-sized queue), because
the internal event no longer counts towards the queue depth.
The main changes in QP v4.1.00 with respect to the earlier versions are
as follows:
- modified functions QActive_post(), QActive_postISR(), and QF_run() in qfn.c
to always use the ring buffer and not to count the internal event as part
of the queue (in the assertions).
- modified qfn.c to replace static variables 'p' and 'a' with automatic
variables.
- modified function QK_schedule_() in qkn.c to always use the ring buffer,
as described above.
- modified module qkn.c to to replace static variables 'p' and 'l_act' with
automatic variables.
- modified various examples to eliminate zero-sized queues and extend event
queues by one event.
- modified the ARM Cortex-M3 examples for the new IAR EWARM 5.40.
- modified the ship.c and tunnel.c files in the "Fly 'n' Shoot" game
example to fix the aforementioned bug.
@section qpn_4_0_04 Version 4.0.04, 2009-04-09
The maintenance release provides a fix for the compile-time assertions,
which did not work correctly for the GNU compiler family. Also, the ARM
Cortex-M3 examples have been recompiled with the newer IAR EWARM v5.30.
This maintenance release does not change the QP-nano API in any way, so the
release has NO IMPACT on the QP-nano applications.
The main changes in QP v4.0.04 with respect to earlier Version are as follows:
- in qassert.h file the #Q_ASSERT_COMPILE macro has been modified to render
a negative array dimension when the asserted condition is not TRUE.
@section qpn_4_0_03 Version 4.0.03, 2008-08-06
The main purpose of this release is to "future-proof" the QK-nano preemptive
kernel. The release 4.0.03 strictly preserves the semantics of QK_currPrio_
variable, which was violated by the previous QK mutex implementation.
The mutex locking now uses a different variable QK_ceilingPrio_, which
represents the ceiling-priority locked by the mutex. When the mutex is
configured (the macro #QK_MUTEX is defined), the QK-nano scheduler
performs an additional check to make sure that only tasks with priorities
above the ceiling can run. This additional overhead is not present when
#QK_MUTEX is not defined.
This maintenance release does not change the QP-nano API in any way, so the
release has NO IMPACT on the QP-nano applications.
The main changes in QP v4.0.03 with respect to earlier Version are as follows:
- in qkn.c file, changed priority-ceiling mutex implementation to use
the QK_ceilingPrio_ instead of QK_currPrio_. Also added testing priority
against the QK_ceilingPrio_, when the macro QK_MUTEX is defined.
@section qpn_4_0_02 Version 4.0.02, 2008-08-06
This maintenace release is made to allow posting events from any active object
to any active object from the top-most initial transtions.
This maintenance release does not change the QP-nano API in any way, so the
release has NO IMPACT on the QP-nano applications.
The main changes in QP v4.0.02 with respect to earlier Version are as follows:
- modified function QF_run() in qfn.c to first loop over all active objects
and initialize their priority attribute based on their location in the
QF_active[] array. The second for-loop triggers only the initial transitions,
but now all priorities are initialized, so active objects can post events to
each others from the initial transitions.
- modified function QF_run() in qkn.c in identical way as in qfn.c described
above.
@section qpn_4_0_01 Version 4.0.01, 2008-06-08
This maintenace release is made to allow compiling QP-nano with the GNU
compiler for AVR (WinAVR). Specifically, some changes were necessary to
accomodate the non-standard way of hanlding constant data objects allocated
in ROM (PROGMEM) in the GNU compiler for AVR.
This maintenance release does not change the QP-nano API in any way, so the
release has NO IMPACT on the QP-nano applications.
The main changes in QP v4.0.01 with respect to earlier Version are as follows:
- eliminated QF_pCB_ variable from qfn.c and qkn.c. This variable was used to
point to the constant active object control block (QActiveCB) in ROM. The GNU
compliler for AVR could not handle such pointer correctly without
contaminating the code with non-portable and non-standard extensions.
- added Doxygen comments to the qep.h header file.
- in qepn.c file, broken up expressions of the form if (t == path[iq]) ...
into (s = path[iq]; if (t == s) ...). This was done to accommodate the
ImageCraft ICCM8C compiler for PSoC.
@section qpn_4_0_00 Version 4.0.00, 2008-04-07
This milestone release is made for the book /ref PSiCC2. The book describes in
great detail this new release. The older "QP-nano Programmer's Manual" is now
phased out and is replaced with this hyper-lirenked
/ref main_page "QP-nano Reference Manual", which provides very detailed,
easily searchable reference to the software. The book /ref PSiCC2 provies
in-depth discussion of the relevant concepts as well as the design study of
QP v4.0, including QP-nano v4.0 in Chapter 12.
The main changes in QP v4.0 with respect to earlier versions are as follows:
- the coding techniques for hierarchical state machines (HSMs) and the simpler
finite state machines (FSMs) have changed. While the changes are quite simple,
the backward compatibility with QEP-nano 3.x has been broken, meaning that
some manual changes to the state machines implemented with earlier versions
are necessary. Please refer to the "QP-nano Tutorial" Section /ref coding_hsm
for more information about coding state machines with QEP 4.x.
- The main change is the signature of a state-handler function, which now
returns simply a byte. This return type (typedef'ed as QState) is the
status of the event-handling that the state handler conveys to the QEP
event processor.
- The macro #Q_TRAN() must now always follow the return statement.
- The new macro #Q_SUPER() designates the superstate of the given state.
Again, this macro must follow the return statement.
- Then two new macros #Q_HANDLED() and #Q_IGNORED() have been added to
return the status of event handled and event ignored, respectively.
- all callback functions are now consistently called /c #XXX_onYYY():
- Q_assert_handler() is now Q_onAssert()
- QF_start() is now QF_onStartup()
- QF_cleanup() is now QF_onCleanup()
- all callback functions are now consistently called /c XXX_onYYY():
- Q_assert_handler() is now Q_onAssert()
- QF_start() is now QF_onStartup()
- QF_cleanup() is now QF_onCleanup()
- enumerating global active object priorities is no longer necessary.
- the methods of posting events have changed:
- QF_post(prio, sig, par) is now void QActive_post(me, sig, par)
- QF_postISR(prio, sig, par) is now void QActive_postISR(me, sig, par)
- the global variable QF_activeNum has been eliminated
- instead the constant #QF_MAX_ACTIVE <STRONG>must</STRONG> correspond
to the exact number of active objects in the application.
- the QEP-nano event processor now works identically as the full-Version QEP.
Specifically, the signal of the current event is not used to notify the event
processor that a transition has taken place. This saves a few bytes of code
for every usage of #Q_TRAN().
- all QF-nano and QK-nano functions have been modified to use static variables
instead of stack variables wherever possible. This saves a few bytes of stack
for the "vanilla" kernel. In QK-nano the savings can be more substantial.
- the QP-nano event queues now decrement the head and tail counters. This
leads to wrap-around at zero, which is easier (faster) to test than any other
wrap-around point.
- all examples in the standard QP-nano distribution have been cleaned up and
updated to the latest QP-nano API changes.
*/
Finally, this release improves the comments in the QF_stop() function. The comments now make it very clear that after calling QF_stop() the application must terminate and cannot continue. In particular, QF_stop() is **not** intended to be followed by a call to QF_init() to "resurrect" the application. The previous comments apparently were confusi
gitextract_iaujvinz/
├── .gitignore
├── .gitmodules
├── GPLv3.txt
├── LICENSE.txt
├── README.md
├── doxygen/
│ ├── Doxyfile
│ ├── Doxyfile-CHM
│ ├── api.dox
│ ├── exa.dox
│ ├── exa_apps.dox
│ ├── exa_native.dox
│ ├── exa_os.dox
│ ├── gs.dox
│ ├── history.dox
│ ├── img/
│ │ └── img.htm
│ ├── lint.dox
│ ├── macros.h
│ ├── main.dox
│ ├── make.bat
│ ├── modules.dox
│ ├── ports.dox
│ ├── ports_arm-cm.dox
│ ├── ports_native.dox
│ ├── ports_os.dox
│ ├── preview.js
│ ├── rsm.bat
│ ├── rsm_qpn.cfg
│ ├── snippets/
│ │ ├── qepn_qhist.c
│ │ ├── qepn_qhsm.c
│ │ ├── qepn_qhsm_ctor.c
│ │ ├── qepn_qhsm_use.c
│ │ ├── qepn_qinit.c
│ │ ├── qepn_qtran.c
│ │ ├── qfn_armx.c
│ │ ├── qfn_main.c
│ │ ├── qfn_post.c
│ │ ├── qfn_postx.c
│ │ ├── qfn_qactive.c
│ │ ├── qfn_tickx.c
│ │ ├── qkn_lock.c
│ │ └── qkn_oncontextsw.c
│ └── struct.dox
├── examples/
│ ├── README.url
│ ├── arm-cm/
│ │ ├── README.url
│ │ ├── blinky_efm32-slstk3401a/
│ │ │ ├── README.txt
│ │ │ ├── README.url
│ │ │ ├── blinky.c
│ │ │ ├── blinky.h
│ │ │ ├── bsp.h
│ │ │ ├── main.c
│ │ │ ├── qk/
│ │ │ │ ├── armclang/
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── blinky-qk.uvoptx
│ │ │ │ │ └── blinky-qk.uvprojx
│ │ │ │ ├── bsp.c
│ │ │ │ ├── gnu/
│ │ │ │ │ ├── Makefile
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── blinky-qk.ld
│ │ │ │ │ └── flash.bat
│ │ │ │ └── iar/
│ │ │ │ ├── README.txt
│ │ │ │ ├── blinky-qk.ewd
│ │ │ │ ├── blinky-qk.ewp
│ │ │ │ ├── blinky-qk.eww
│ │ │ │ └── blinky-qk.icf
│ │ │ ├── qpn_conf.h
│ │ │ └── qv/
│ │ │ ├── armclang/
│ │ │ │ ├── README.txt
│ │ │ │ ├── blinky-qv.uvoptx
│ │ │ │ └── blinky-qv.uvprojx
│ │ │ ├── bsp.c
│ │ │ ├── gnu/
│ │ │ │ ├── Makefile
│ │ │ │ ├── README.txt
│ │ │ │ ├── blinky-qv.ld
│ │ │ │ └── flash.bat
│ │ │ └── iar/
│ │ │ ├── README.txt
│ │ │ ├── blinky-qv.ewd
│ │ │ ├── blinky-qv.ewp
│ │ │ ├── blinky-qv.eww
│ │ │ └── blinky-qv.icf
│ │ ├── blinky_ek-tm4c123gxl/
│ │ │ ├── README.txt
│ │ │ ├── README.url
│ │ │ ├── blinky.c
│ │ │ ├── blinky.h
│ │ │ ├── bsp.h
│ │ │ ├── main.c
│ │ │ ├── qk/
│ │ │ │ ├── arm/
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── blinky-qk.uvoptx
│ │ │ │ │ └── blinky-qk.uvprojx
│ │ │ │ ├── armclang/
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── blinky-qk.uvoptx
│ │ │ │ │ └── blinky-qk.uvprojx
│ │ │ │ ├── bsp.c
│ │ │ │ ├── gnu/
│ │ │ │ │ ├── .ccsproject
│ │ │ │ │ ├── .cproject
│ │ │ │ │ ├── .project
│ │ │ │ │ ├── Makefile
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── blinky-qk.ld
│ │ │ │ │ └── flash.bat
│ │ │ │ └── iar/
│ │ │ │ ├── README.txt
│ │ │ │ ├── blinky-qk.ewd
│ │ │ │ ├── blinky-qk.ewp
│ │ │ │ ├── blinky-qk.eww
│ │ │ │ └── blinky-qk.icf
│ │ │ ├── qpn_conf.h
│ │ │ └── qv/
│ │ │ ├── arm/
│ │ │ │ ├── README.txt
│ │ │ │ ├── blinky-qv.uvoptx
│ │ │ │ └── blinky-qv.uvprojx
│ │ │ ├── armclang/
│ │ │ │ ├── README.txt
│ │ │ │ ├── blinky-qv.uvoptx
│ │ │ │ └── blinky-qv.uvprojx
│ │ │ ├── bsp.c
│ │ │ ├── gnu/
│ │ │ │ ├── .ccsproject
│ │ │ │ ├── .cproject
│ │ │ │ ├── .project
│ │ │ │ ├── Makefile
│ │ │ │ ├── README.txt
│ │ │ │ ├── blinky-qv.ld
│ │ │ │ └── flash.bat
│ │ │ └── iar/
│ │ │ ├── README.txt
│ │ │ ├── blinky-qv.ewd
│ │ │ ├── blinky-qv.ewp
│ │ │ ├── blinky-qv.eww
│ │ │ └── blinky-qv.icf
│ │ ├── dpp_efm32-slstk3401a/
│ │ │ ├── README.txt
│ │ │ ├── README.url
│ │ │ ├── bsp.h
│ │ │ ├── dpp.h
│ │ │ ├── dpp.qm
│ │ │ ├── main.c
│ │ │ ├── philo.c
│ │ │ ├── qk/
│ │ │ │ ├── armclang/
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── dpp-qk.uvoptx
│ │ │ │ │ └── dpp-qk.uvprojx
│ │ │ │ ├── bsp.c
│ │ │ │ ├── gnu/
│ │ │ │ │ ├── Makefile
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── dpp-qk.ld
│ │ │ │ │ └── flash.bat
│ │ │ │ └── iar/
│ │ │ │ ├── README.txt
│ │ │ │ ├── dpp-qk.ewd
│ │ │ │ ├── dpp-qk.ewp
│ │ │ │ ├── dpp-qk.eww
│ │ │ │ └── dpp-qk.icf
│ │ │ ├── qpn_conf.h
│ │ │ ├── qv/
│ │ │ │ ├── armclang/
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── dpp-qv.uvoptx
│ │ │ │ │ └── dpp-qv.uvprojx
│ │ │ │ ├── bsp.c
│ │ │ │ ├── gnu/
│ │ │ │ │ ├── Makefile
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── dpp-qv.ld
│ │ │ │ │ └── flash.bat
│ │ │ │ └── iar/
│ │ │ │ ├── README.txt
│ │ │ │ ├── dpp-qv.ewd
│ │ │ │ ├── dpp-qv.ewp
│ │ │ │ ├── dpp-qv.eww
│ │ │ │ └── dpp-qv.icf
│ │ │ ├── table.c
│ │ │ └── win32-gui/
│ │ │ ├── Resource.rc
│ │ │ ├── bsp.c
│ │ │ ├── dpp-gui.sln
│ │ │ ├── dpp-gui.vcxproj
│ │ │ ├── dpp-gui.vcxproj.filters
│ │ │ └── resource.h
│ │ ├── dpp_ek-tm4c123gxl/
│ │ │ ├── README.txt
│ │ │ ├── README.url
│ │ │ ├── bsp.h
│ │ │ ├── dpp.h
│ │ │ ├── dpp.qm
│ │ │ ├── lint-plus/
│ │ │ │ ├── README.txt
│ │ │ │ ├── lin.bat
│ │ │ │ └── options.lnt
│ │ │ ├── main.c
│ │ │ ├── philo.c
│ │ │ ├── qk/
│ │ │ │ ├── arm/
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── dpp-qk.uvoptx
│ │ │ │ │ └── dpp-qk.uvprojx
│ │ │ │ ├── armclang/
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── dpp-qk.uvoptx
│ │ │ │ │ └── dpp-qk.uvprojx
│ │ │ │ ├── bsp.c
│ │ │ │ ├── gnu/
│ │ │ │ │ ├── .ccsproject
│ │ │ │ │ ├── .cproject
│ │ │ │ │ ├── .project
│ │ │ │ │ ├── Makefile
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── dpp-qk.ld
│ │ │ │ │ └── flash.bat
│ │ │ │ └── iar/
│ │ │ │ ├── README.txt
│ │ │ │ ├── dpp-qk.ewd
│ │ │ │ ├── dpp-qk.ewp
│ │ │ │ ├── dpp-qk.eww
│ │ │ │ └── dpp-qk.icf
│ │ │ ├── qpn_conf.h
│ │ │ ├── qv/
│ │ │ │ ├── arm/
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── dpp-qv.uvoptx
│ │ │ │ │ └── dpp-qv.uvprojx
│ │ │ │ ├── armclang/
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── dpp-qv.uvoptx
│ │ │ │ │ └── dpp-qv.uvprojx
│ │ │ │ ├── bsp.c
│ │ │ │ ├── gnu/
│ │ │ │ │ ├── .ccsproject
│ │ │ │ │ ├── .cproject
│ │ │ │ │ ├── .project
│ │ │ │ │ ├── Makefile
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── dpp-qv.ld
│ │ │ │ │ └── flash.bat
│ │ │ │ └── iar/
│ │ │ │ ├── README.txt
│ │ │ │ ├── dpp-qv.ewd
│ │ │ │ ├── dpp-qv.ewp
│ │ │ │ ├── dpp-qv.eww
│ │ │ │ └── dpp-qv.icf
│ │ │ └── table.c
│ │ ├── dpp_mbed-lpc1768/
│ │ │ ├── README.txt
│ │ │ ├── README.url
│ │ │ ├── bsp.h
│ │ │ ├── dpp.h
│ │ │ ├── dpp.qm
│ │ │ ├── main.c
│ │ │ ├── philo.c
│ │ │ ├── qk/
│ │ │ │ ├── armclang/
│ │ │ │ │ ├── dpp-qk.uvoptx
│ │ │ │ │ └── dpp-qk.uvprojx
│ │ │ │ ├── bsp.c
│ │ │ │ ├── gnu/
│ │ │ │ │ ├── Makefile
│ │ │ │ │ └── dpp-qk.ld
│ │ │ │ └── iar/
│ │ │ │ ├── dpp-qk.ewd
│ │ │ │ ├── dpp-qk.ewp
│ │ │ │ ├── dpp-qk.eww
│ │ │ │ └── dpp-qk.icf
│ │ │ ├── qpn_conf.h
│ │ │ ├── qv/
│ │ │ │ ├── armclang/
│ │ │ │ │ ├── dpp-qv.uvoptx
│ │ │ │ │ └── dpp-qv.uvprojx
│ │ │ │ ├── bsp.c
│ │ │ │ ├── gnu/
│ │ │ │ │ ├── Makefile
│ │ │ │ │ └── dpp-qv.ld
│ │ │ │ └── iar/
│ │ │ │ ├── dpp-qv.ewd
│ │ │ │ ├── dpp-qv.ewp
│ │ │ │ ├── dpp-qv.eww
│ │ │ │ └── dpp-qv.icf
│ │ │ └── table.c
│ │ ├── dpp_nucleo-l053r8/
│ │ │ ├── README.txt
│ │ │ ├── README.url
│ │ │ ├── bsp.h
│ │ │ ├── dpp.h
│ │ │ ├── dpp.qm
│ │ │ ├── main.c
│ │ │ ├── philo.c
│ │ │ ├── qk/
│ │ │ │ ├── armclang/
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── dpp-qk.uvoptx
│ │ │ │ │ └── dpp-qk.uvprojx
│ │ │ │ ├── bsp.c
│ │ │ │ ├── gnu/
│ │ │ │ │ ├── .cproject
│ │ │ │ │ ├── .project
│ │ │ │ │ ├── Makefile
│ │ │ │ │ ├── dpp-qk.ld
│ │ │ │ │ ├── dpp-qk_nucleo-l053r8.elf.launch
│ │ │ │ │ └── stm32_flash.ld
│ │ │ │ └── iar/
│ │ │ │ ├── dpp-qk.ewd
│ │ │ │ ├── dpp-qk.ewp
│ │ │ │ ├── dpp-qk.eww
│ │ │ │ └── dpp-qk.icf
│ │ │ ├── qpn_conf.h
│ │ │ ├── qv/
│ │ │ │ ├── armclang/
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── dpp-qv.uvoptx
│ │ │ │ │ └── dpp-qv.uvprojx
│ │ │ │ ├── bsp.c
│ │ │ │ ├── gnu/
│ │ │ │ │ ├── .cproject
│ │ │ │ │ ├── .project
│ │ │ │ │ ├── Makefile
│ │ │ │ │ └── dpp-qv.ld
│ │ │ │ └── iar/
│ │ │ │ ├── dpp-qv.ewd
│ │ │ │ ├── dpp-qv.ewp
│ │ │ │ ├── dpp-qv.eww
│ │ │ │ └── dpp-qv.icf
│ │ │ └── table.c
│ │ ├── dpp_nucleo-l152re/
│ │ │ ├── README.txt
│ │ │ ├── README.url
│ │ │ ├── bsp.h
│ │ │ ├── dpp.h
│ │ │ ├── dpp.qm
│ │ │ ├── main.c
│ │ │ ├── philo.c
│ │ │ ├── qk/
│ │ │ │ ├── armclang/
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── dpp-qk.uvoptx
│ │ │ │ │ └── dpp-qk.uvprojx
│ │ │ │ ├── bsp.c
│ │ │ │ ├── gnu/
│ │ │ │ │ ├── .cproject
│ │ │ │ │ ├── .project
│ │ │ │ │ ├── Makefile
│ │ │ │ │ └── dpp-qk.ld
│ │ │ │ └── iar/
│ │ │ │ ├── dpp-qk.ewd
│ │ │ │ ├── dpp-qk.ewp
│ │ │ │ ├── dpp-qk.eww
│ │ │ │ └── dpp-qk.icf
│ │ │ ├── qpn_conf.h
│ │ │ ├── qv/
│ │ │ │ ├── armclang/
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── dpp-qv.uvoptx
│ │ │ │ │ └── dpp-qv.uvprojx
│ │ │ │ ├── bsp.c
│ │ │ │ ├── gnu/
│ │ │ │ │ ├── .cproject
│ │ │ │ │ ├── .project
│ │ │ │ │ ├── Makefile
│ │ │ │ │ └── dpp-qv.ld
│ │ │ │ └── iar/
│ │ │ │ ├── dpp-qv.ewd
│ │ │ │ ├── dpp-qv.ewp
│ │ │ │ ├── dpp-qv.eww
│ │ │ │ └── dpp-qv.icf
│ │ │ └── table.c
│ │ ├── game_efm32-slstk3401a/
│ │ │ ├── README.txt
│ │ │ ├── README.url
│ │ │ ├── bsp.h
│ │ │ ├── game.h
│ │ │ ├── game.qm
│ │ │ ├── main.c
│ │ │ ├── mine1.c
│ │ │ ├── mine2.c
│ │ │ ├── missile.c
│ │ │ ├── qk/
│ │ │ │ ├── armclang/
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── game-qk.uvoptx
│ │ │ │ │ └── game-qk.uvprojx
│ │ │ │ ├── bsp.c
│ │ │ │ ├── gnu/
│ │ │ │ │ ├── Makefile
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── flash.bat
│ │ │ │ │ └── game-qk.ld
│ │ │ │ └── iar/
│ │ │ │ ├── README.txt
│ │ │ │ ├── game-qk.ewd
│ │ │ │ ├── game-qk.ewp
│ │ │ │ ├── game-qk.eww
│ │ │ │ └── game-qk.icf
│ │ │ ├── qpn_conf.h
│ │ │ ├── qv/
│ │ │ │ ├── armclang/
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── game-qv.uvoptx
│ │ │ │ │ └── game-qv.uvprojx
│ │ │ │ ├── bsp.c
│ │ │ │ ├── gnu/
│ │ │ │ │ ├── Makefile
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── flash.bat
│ │ │ │ │ └── game-qv.ld
│ │ │ │ └── iar/
│ │ │ │ ├── README.txt
│ │ │ │ ├── game-qv.ewd
│ │ │ │ ├── game-qv.ewp
│ │ │ │ ├── game-qv.eww
│ │ │ │ └── game-qv.icf
│ │ │ ├── ship.c
│ │ │ ├── tunnel.c
│ │ │ └── win32-gui/
│ │ │ ├── Resource.rc
│ │ │ ├── bsp.c
│ │ │ ├── game-gui.sln
│ │ │ ├── game-gui.vcxproj
│ │ │ ├── game-gui.vcxproj.filters
│ │ │ └── resource.h
│ │ └── pelican_ek-tm4c123gxl/
│ │ ├── README.url
│ │ ├── bsp.h
│ │ ├── main.c
│ │ ├── pelican.c
│ │ ├── pelican.h
│ │ ├── pelican.qm
│ │ ├── qk/
│ │ │ ├── armclang/
│ │ │ │ ├── README.txt
│ │ │ │ ├── pelican-qk.uvoptx
│ │ │ │ └── pelican-qk.uvprojx
│ │ │ ├── bsp.c
│ │ │ ├── gnu/
│ │ │ │ ├── Makefile
│ │ │ │ ├── README.txt
│ │ │ │ ├── flash.bat
│ │ │ │ └── pelican-qk.ld
│ │ │ └── iar/
│ │ │ ├── README.txt
│ │ │ ├── pelican-qk.ewd
│ │ │ ├── pelican-qk.ewp
│ │ │ ├── pelican-qk.eww
│ │ │ └── pelican-qk.icf
│ │ ├── qpn_conf.h
│ │ └── qv/
│ │ ├── armclang/
│ │ │ ├── README.txt
│ │ │ ├── pelican-qv.uvoptx
│ │ │ └── pelican-qv.uvprojx
│ │ ├── bsp.c
│ │ ├── gnu/
│ │ │ ├── Makefile
│ │ │ ├── README.txt
│ │ │ ├── flash.bat
│ │ │ └── pelican-qv.ld
│ │ └── iar/
│ │ ├── README.txt
│ │ ├── pelican-qv.ewd
│ │ ├── pelican-qv.ewp
│ │ ├── pelican-qv.eww
│ │ └── pelican-qv.icf
│ ├── arm7-9/
│ │ ├── README.url
│ │ └── dpp_at91sam7s-ek/
│ │ ├── README.url
│ │ ├── bsp.h
│ │ ├── dpp.h
│ │ ├── dpp.qm
│ │ ├── main.c
│ │ ├── philo.c
│ │ ├── qk/
│ │ │ └── iar/
│ │ │ ├── at91SAM7S64.icf
│ │ │ ├── bsp.c
│ │ │ ├── dpp-qk.ewd
│ │ │ ├── dpp-qk.ewp
│ │ │ └── dpp-qk.eww
│ │ ├── qpn_conf.h
│ │ ├── qv/
│ │ │ └── iar/
│ │ │ ├── at91SAM7S64.icf
│ │ │ ├── bsp.c
│ │ │ ├── dpp-qv.ewd
│ │ │ ├── dpp-qv.ewp
│ │ │ └── dpp-qv.eww
│ │ └── table.c
│ ├── avr/
│ │ ├── README.url
│ │ ├── blinky_arduino-uno/
│ │ │ ├── README.url
│ │ │ ├── blinky.c
│ │ │ ├── blinky.h
│ │ │ ├── bsp.h
│ │ │ ├── main.c
│ │ │ ├── qk/
│ │ │ │ ├── gnu/
│ │ │ │ │ ├── Makefile
│ │ │ │ │ ├── README.txt
│ │ │ │ │ ├── bsp.c
│ │ │ │ │ └── flash.bat
│ │ │ │ └── iar/
│ │ │ │ ├── blinky-qk.ewd
│ │ │ │ ├── blinky-qk.ewp
│ │ │ │ ├── blinky-qk.eww
│ │ │ │ ├── bsp.c
│ │ │ │ └── flash.bat
│ │ │ ├── qpn_conf.h
│ │ │ └── qv/
│ │ │ ├── gnu/
│ │ │ │ ├── Makefile
│ │ │ │ ├── README.txt
│ │ │ │ ├── bsp.c
│ │ │ │ └── flash.bat
│ │ │ └── iar/
│ │ │ ├── blinky-qv.ewd
│ │ │ ├── blinky-qv.ewp
│ │ │ ├── blinky-qv.eww
│ │ │ ├── bsp.c
│ │ │ └── flash.bat
│ │ └── dpp_arduino-uno/
│ │ ├── README.url
│ │ ├── bsp.h
│ │ ├── dpp.h
│ │ ├── dpp.qm
│ │ ├── main.c
│ │ ├── philo.c
│ │ ├── qk/
│ │ │ ├── gnu/
│ │ │ │ ├── Makefile
│ │ │ │ ├── README.txt
│ │ │ │ ├── bsp.c
│ │ │ │ └── flash.bat
│ │ │ └── iar/
│ │ │ ├── README.txt
│ │ │ ├── bsp.c
│ │ │ ├── dpp-qk.ewd
│ │ │ ├── dpp-qk.ewp
│ │ │ ├── dpp-qk.eww
│ │ │ ├── flash.bat
│ │ │ └── spy.bat
│ │ ├── qpn_conf.h
│ │ ├── qv/
│ │ │ ├── gnu/
│ │ │ │ ├── Makefile
│ │ │ │ ├── README.txt
│ │ │ │ ├── bsp.c
│ │ │ │ ├── flash.bat
│ │ │ │ └── spy.bat
│ │ │ └── iar/
│ │ │ ├── README.txt
│ │ │ ├── bsp.c
│ │ │ ├── dpp-qv.ewd
│ │ │ ├── dpp-qv.ewp
│ │ │ ├── dpp-qv.eww
│ │ │ ├── flash.bat
│ │ │ └── spy.bat
│ │ └── table.c
│ ├── msp430/
│ │ ├── README.url
│ │ ├── blinky_msp-exp430f5529lp/
│ │ │ ├── README.url
│ │ │ ├── blinky.c
│ │ │ ├── blinky.h
│ │ │ ├── bsp.h
│ │ │ ├── main.c
│ │ │ ├── qk/
│ │ │ │ ├── bsp.c
│ │ │ │ ├── ccs/
│ │ │ │ │ ├── .ccsproject
│ │ │ │ │ ├── .cproject
│ │ │ │ │ ├── .project
│ │ │ │ │ └── lnk_msp430f5529.cmd
│ │ │ │ └── iar/
│ │ │ │ ├── blinky-qk.ewd
│ │ │ │ ├── blinky-qk.ewp
│ │ │ │ └── blinky-qk.eww
│ │ │ ├── qpn_conf.h
│ │ │ └── qv/
│ │ │ ├── bsp.c
│ │ │ ├── ccs/
│ │ │ │ ├── .ccsproject
│ │ │ │ ├── .cproject
│ │ │ │ ├── .project
│ │ │ │ └── lnk_msp430f5529.cmd
│ │ │ └── iar/
│ │ │ ├── blinky-qv.ewd
│ │ │ ├── blinky-qv.ewp
│ │ │ └── blinky-qv.eww
│ │ ├── blinky_msp-exp430g2/
│ │ │ ├── README.url
│ │ │ ├── blinky.c
│ │ │ ├── blinky.h
│ │ │ ├── bsp.h
│ │ │ ├── main.c
│ │ │ ├── qk/
│ │ │ │ ├── bsp.c
│ │ │ │ ├── ccs/
│ │ │ │ │ ├── .ccsproject
│ │ │ │ │ ├── .cproject
│ │ │ │ │ ├── .project
│ │ │ │ │ └── lnk_msp430g2553.cmd
│ │ │ │ └── iar/
│ │ │ │ ├── blinky-qk.ewd
│ │ │ │ ├── blinky-qk.ewp
│ │ │ │ └── blinky-qk.eww
│ │ │ ├── qpn_conf.h
│ │ │ └── qv/
│ │ │ ├── bsp.c
│ │ │ ├── ccs/
│ │ │ │ ├── .ccsproject
│ │ │ │ ├── .cproject
│ │ │ │ ├── .project
│ │ │ │ └── lnk_msp430g2553.cmd
│ │ │ └── iar/
│ │ │ ├── blinky-qv.ewd
│ │ │ ├── blinky-qv.ewp
│ │ │ └── blinky-qv.eww
│ │ └── dpp_msp-exp430g2/
│ │ ├── README.url
│ │ ├── bsp.h
│ │ ├── dpp.h
│ │ ├── dpp.qm
│ │ ├── main.c
│ │ ├── philo.c
│ │ ├── qk/
│ │ │ ├── bsp.c
│ │ │ ├── ccs/
│ │ │ │ ├── .ccsproject
│ │ │ │ ├── .cproject
│ │ │ │ ├── .project
│ │ │ │ └── lnk_msp430g2553.cmd
│ │ │ └── iar/
│ │ │ ├── dpp-qk.ewd
│ │ │ ├── dpp-qk.ewp
│ │ │ └── dpp-qk.eww
│ │ ├── qpn_conf.h
│ │ ├── qv/
│ │ │ ├── bsp.c
│ │ │ ├── ccs/
│ │ │ │ ├── .ccsproject
│ │ │ │ ├── .cproject
│ │ │ │ ├── .project
│ │ │ │ └── lnk_msp430g2553.cmd
│ │ │ └── iar/
│ │ │ ├── dpp-qv.ewd
│ │ │ ├── dpp-qv.ewp
│ │ │ └── dpp-qv.eww
│ │ └── table.c
│ ├── pic24_dspic/
│ │ ├── blinky_microstick2-pic24/
│ │ │ ├── blinky.c
│ │ │ ├── blinky.h
│ │ │ ├── bsp.h
│ │ │ ├── main.c
│ │ │ ├── qk/
│ │ │ │ └── xc16/
│ │ │ │ ├── Makefile
│ │ │ │ ├── bsp.c
│ │ │ │ └── nbproject/
│ │ │ │ ├── Makefile-default.mk
│ │ │ │ ├── Makefile-genesis.properties
│ │ │ │ ├── Makefile-impl.mk
│ │ │ │ ├── Makefile-local-default.mk
│ │ │ │ ├── Makefile-local-release.mk
│ │ │ │ ├── Makefile-release.mk
│ │ │ │ ├── Makefile-variables.mk
│ │ │ │ ├── Package-default.bash
│ │ │ │ ├── Package-release.bash
│ │ │ │ ├── configurations.xml
│ │ │ │ ├── private/
│ │ │ │ │ ├── configurations.xml
│ │ │ │ │ ├── private.properties
│ │ │ │ │ └── private.xml
│ │ │ │ ├── project.properties
│ │ │ │ └── project.xml
│ │ │ ├── qpn_conf.h
│ │ │ └── qv/
│ │ │ └── xc16/
│ │ │ ├── Makefile
│ │ │ ├── bsp.c
│ │ │ └── nbproject/
│ │ │ ├── Makefile-default.mk
│ │ │ ├── Makefile-genesis.properties
│ │ │ ├── Makefile-impl.mk
│ │ │ ├── Makefile-local-default.mk
│ │ │ ├── Makefile-local-release.mk
│ │ │ ├── Makefile-release.mk
│ │ │ ├── Makefile-variables.mk
│ │ │ ├── Package-default.bash
│ │ │ ├── Package-release.bash
│ │ │ ├── configurations.xml
│ │ │ ├── private/
│ │ │ │ ├── configurations.xml
│ │ │ │ ├── private.properties
│ │ │ │ └── private.xml
│ │ │ ├── project.properties
│ │ │ └── project.xml
│ │ ├── dpp_microstick2-pic24/
│ │ │ ├── bsp.h
│ │ │ ├── dpp.h
│ │ │ ├── dpp.qm
│ │ │ ├── main.c
│ │ │ ├── philo.c
│ │ │ ├── qk/
│ │ │ │ └── xc16/
│ │ │ │ ├── Makefile
│ │ │ │ ├── bsp.c
│ │ │ │ └── nbproject/
│ │ │ │ ├── Makefile-default.mk
│ │ │ │ ├── Makefile-genesis.properties
│ │ │ │ ├── Makefile-impl.mk
│ │ │ │ ├── Makefile-local-default.mk
│ │ │ │ ├── Makefile-local-release.mk
│ │ │ │ ├── Makefile-release.mk
│ │ │ │ ├── Makefile-variables.mk
│ │ │ │ ├── Package-default.bash
│ │ │ │ ├── Package-release.bash
│ │ │ │ ├── configurations.xml
│ │ │ │ ├── private/
│ │ │ │ │ ├── configurations.xml
│ │ │ │ │ ├── private.properties
│ │ │ │ │ └── private.xml
│ │ │ │ ├── project.properties
│ │ │ │ └── project.xml
│ │ │ ├── qpn_conf.h
│ │ │ ├── qv/
│ │ │ │ └── xc16/
│ │ │ │ ├── Makefile
│ │ │ │ ├── bsp.c
│ │ │ │ └── nbproject/
│ │ │ │ ├── Makefile-default.mk
│ │ │ │ ├── Makefile-genesis.properties
│ │ │ │ ├── Makefile-impl.mk
│ │ │ │ ├── Makefile-local-default.mk
│ │ │ │ ├── Makefile-local-release.mk
│ │ │ │ ├── Makefile-release.mk
│ │ │ │ ├── Makefile-variables.mk
│ │ │ │ ├── Package-default.bash
│ │ │ │ ├── Package-release.bash
│ │ │ │ ├── configurations.xml
│ │ │ │ ├── private/
│ │ │ │ │ ├── configurations.xml
│ │ │ │ │ ├── private.properties
│ │ │ │ │ └── private.xml
│ │ │ │ ├── project.properties
│ │ │ │ └── project.xml
│ │ │ └── table.c
│ │ └── pelican_microstick2-pic24/
│ │ ├── bsp.h
│ │ ├── main.c
│ │ ├── pelican.c
│ │ ├── pelican.h
│ │ ├── pelican.qm
│ │ ├── qk/
│ │ │ └── xc16/
│ │ │ ├── Makefile
│ │ │ ├── bsp.c
│ │ │ └── nbproject/
│ │ │ ├── Makefile-default.mk
│ │ │ ├── Makefile-genesis.properties
│ │ │ ├── Makefile-impl.mk
│ │ │ ├── Makefile-local-default.mk
│ │ │ ├── Makefile-local-release.mk
│ │ │ ├── Makefile-release.mk
│ │ │ ├── Makefile-variables.mk
│ │ │ ├── Package-default.bash
│ │ │ ├── Package-release.bash
│ │ │ ├── configurations.xml
│ │ │ ├── private/
│ │ │ │ ├── configurations.xml
│ │ │ │ ├── private.properties
│ │ │ │ └── private.xml
│ │ │ ├── project.properties
│ │ │ └── project.xml
│ │ ├── qpn_conf.h
│ │ └── qv/
│ │ └── xc16/
│ │ ├── Makefile
│ │ ├── bsp.c
│ │ └── nbproject/
│ │ ├── Makefile-default.mk
│ │ ├── Makefile-genesis.properties
│ │ ├── Makefile-impl.mk
│ │ ├── Makefile-local-default.mk
│ │ ├── Makefile-local-release.mk
│ │ ├── Makefile-release.mk
│ │ ├── Makefile-variables.mk
│ │ ├── Package-default.bash
│ │ ├── Package-release.bash
│ │ ├── configurations.xml
│ │ ├── private/
│ │ │ ├── configurations.xml
│ │ │ ├── private.properties
│ │ │ └── private.xml
│ │ ├── project.properties
│ │ └── project.xml
│ └── workstation/
│ ├── README.txt
│ ├── blinky/
│ │ ├── Makefile
│ │ ├── README.txt
│ │ ├── blinky.c
│ │ ├── blinky.qm
│ │ └── qpn_conf.h
│ ├── calc/
│ │ ├── Makefile
│ │ ├── bsp.c
│ │ ├── bsp.h
│ │ ├── calc.c
│ │ ├── calc.h
│ │ ├── calc.qm
│ │ ├── main.c
│ │ └── qpn_conf.h
│ ├── comp/
│ │ ├── Makefile
│ │ ├── alarm.c
│ │ ├── alarm.h
│ │ ├── bsp.c
│ │ ├── bsp.h
│ │ ├── clock.h
│ │ ├── comp.c
│ │ ├── main.c
│ │ └── qpn_conf.h
│ ├── defer/
│ │ ├── Makefile
│ │ ├── bsp.c
│ │ ├── bsp.h
│ │ ├── defer.c
│ │ ├── defer.h
│ │ ├── main.c
│ │ └── qpn_conf.h
│ ├── dpp/
│ │ ├── Makefile
│ │ ├── bsp.c
│ │ ├── bsp.h
│ │ ├── dpp.h
│ │ ├── dpp.qm
│ │ ├── dpp.sln
│ │ ├── dpp.vcxproj
│ │ ├── dpp.vcxproj.filters
│ │ ├── main.c
│ │ ├── philo.c
│ │ ├── qpn_conf.h
│ │ └── table.c
│ ├── dpp-comp/
│ │ ├── Makefile
│ │ ├── bsp.c
│ │ ├── bsp.h
│ │ ├── dpp.h
│ │ ├── dpp.sln
│ │ ├── dpp.vcxproj
│ │ ├── dpp.vcxproj.filters
│ │ ├── dpp_comp.qm
│ │ ├── main.c
│ │ ├── philo.c
│ │ ├── qpn_conf.h
│ │ └── table.c
│ ├── dpp-gui/
│ │ └── README.txt
│ ├── game-gui/
│ │ └── README.txt
│ ├── history/
│ │ ├── Makefile
│ │ ├── bsp.c
│ │ ├── bsp.h
│ │ ├── history.c
│ │ ├── history.h
│ │ ├── history.qm
│ │ ├── main.c
│ │ └── qpn_conf.h
│ ├── pelican/
│ │ ├── Makefile
│ │ ├── bsp.c
│ │ ├── bsp.h
│ │ ├── main.c
│ │ ├── pelican.c
│ │ ├── pelican.h
│ │ ├── pelican.qm
│ │ └── qpn_conf.h
│ ├── qhsmtst/
│ │ ├── Makefile
│ │ ├── bsp.c
│ │ ├── bsp.h
│ │ ├── log.txt
│ │ ├── main.c
│ │ ├── qhsmtst.c
│ │ ├── qhsmtst.h
│ │ ├── qhsmtst.qm
│ │ └── qpn_conf.h
│ ├── reminder/
│ │ ├── Makefile
│ │ ├── bsp.c
│ │ ├── bsp.h
│ │ ├── main.c
│ │ ├── qpn_conf.h
│ │ ├── reminder.c
│ │ └── reminder.h
│ └── reminder2/
│ ├── Makefile
│ ├── bsp.c
│ ├── bsp.h
│ ├── main.c
│ ├── qpn_conf.h
│ ├── reminder2.c
│ └── reminder2.h
├── include/
│ ├── qassert.h
│ ├── qepn.h
│ ├── qfn.h
│ ├── qkn.h
│ ├── qpn.h
│ ├── qstamp.c
│ └── qvn.h
├── ports/
│ ├── README.url
│ ├── arm-cm/
│ │ ├── README.url
│ │ ├── qk/
│ │ │ ├── arm/
│ │ │ │ ├── qfn_port.h
│ │ │ │ └── qkn_port.c
│ │ │ ├── armclang/
│ │ │ │ ├── qfn_port.h
│ │ │ │ └── qkn_port.c
│ │ │ ├── gnu/
│ │ │ │ ├── qfn_port.h
│ │ │ │ └── qkn_port.c
│ │ │ └── iar/
│ │ │ ├── qfn_port.h
│ │ │ └── qkn_port.c
│ │ └── qv/
│ │ ├── arm/
│ │ │ ├── qfn_port.h
│ │ │ └── qvn_port.c
│ │ ├── armclang/
│ │ │ ├── qfn_port.h
│ │ │ └── qvn_port.c
│ │ ├── gnu/
│ │ │ ├── qfn_port.h
│ │ │ └── qvn_port.c
│ │ └── iar/
│ │ ├── qfn_port.h
│ │ └── qvn_port.c
│ ├── arm7-9/
│ │ ├── README.url
│ │ ├── qk/
│ │ │ ├── README.url
│ │ │ ├── gnu/
│ │ │ │ ├── qfn_port.h
│ │ │ │ └── qkn_port.s
│ │ │ └── iar/
│ │ │ ├── qfn_port.h
│ │ │ └── qkn_port.s
│ │ └── qv/
│ │ ├── README.url
│ │ ├── gnu/
│ │ │ ├── qfn_port.h
│ │ │ └── qvn_port.s
│ │ └── iar/
│ │ ├── qfn_port.h
│ │ └── qvn_port.s
│ ├── avr/
│ │ ├── README.txt
│ │ ├── README.url
│ │ ├── qk/
│ │ │ ├── gnu/
│ │ │ │ ├── README.txt
│ │ │ │ └── qfn_port.h
│ │ │ └── iar/
│ │ │ └── qfn_port.h
│ │ └── qv/
│ │ ├── gnu/
│ │ │ ├── README.txt
│ │ │ └── qfn_port.h
│ │ └── iar/
│ │ └── qfn_port.h
│ ├── lint-plus/
│ │ ├── 16bit/
│ │ │ ├── cpu.lnt
│ │ │ └── stdint.h
│ │ ├── 32bit/
│ │ │ ├── cpu.lnt
│ │ │ └── stdint.h
│ │ ├── au-ds.lnt
│ │ ├── au-misra3-amd1.lnt
│ │ ├── au-misra3.lnt
│ │ ├── lin.bat
│ │ ├── options.lnt
│ │ ├── qkn/
│ │ │ └── qfn_port.h
│ │ ├── qpn.lnt
│ │ ├── qpn_conf.h
│ │ ├── qvn/
│ │ │ └── qfn_port.h
│ │ ├── std.lnt
│ │ └── stdbool.h
│ ├── msp430/
│ │ ├── README.txt
│ │ ├── README.url
│ │ ├── qk/
│ │ │ ├── ccs/
│ │ │ │ ├── README.txt
│ │ │ │ └── qfn_port.h
│ │ │ └── iar/
│ │ │ └── qfn_port.h
│ │ └── qv/
│ │ ├── ccs/
│ │ │ ├── README.txt
│ │ │ └── qfn_port.h
│ │ └── iar/
│ │ └── qfn_port.h
│ ├── pic24_dspic/
│ │ ├── qk/
│ │ │ └── xc16/
│ │ │ ├── qfn_port.h
│ │ │ └── qkn_port.c
│ │ └── qv/
│ │ └── xc16/
│ │ └── qfn_port.h
│ ├── posix-qv/
│ │ ├── README.url
│ │ ├── qfn_port.h
│ │ ├── qfn_posix.c
│ │ └── safe_std.h
│ └── win32-qv/
│ ├── README.url
│ ├── qfn_port.h
│ ├── qfn_win32.c
│ ├── qwin_gui.c
│ ├── qwin_gui.h
│ └── safe_std.h
└── src/
├── qfn/
│ ├── qepn.c
│ └── qfn.c
├── qkn/
│ └── qkn.c
└── qvn/
└── qvn.c
SYMBOL INDEX (1228 symbols across 197 files)
FILE: doxygen/snippets/qepn_qhist.c
type ToastOven (line 1) | typedef struct {
function QState (line 8) | static QState ToastOven_doorClosed(ToastOven * const me) {
function QState (line 21) | static QState ToastOven_doorOpen(ToastOven * const me) {
FILE: doxygen/snippets/qepn_qhsm.c
type Calc (line 1) | typedef struct {
FILE: doxygen/snippets/qepn_qhsm_ctor.c
function Alarm_ctor (line 1) | void Alarm_ctor(Alarm * const me) {
FILE: doxygen/snippets/qepn_qhsm_use.c
function main (line 8) | int main() {
FILE: doxygen/snippets/qepn_qinit.c
function Pelican_ctor (line 2) | void Pelican_ctor(Pelican * const me) {
function QState (line 7) | QState Pelican_initial(Pelican * const me) { /* the initial pseudo-state */
function QState (line 11) | QState Pelican_operational(Pelican * const me) { /* a regular state hand...
FILE: doxygen/snippets/qepn_qtran.c
function QState (line 2) | QState Pelican_carsGreenNoPed(Pelican * const me) {
function QState (line 26) | QState Pelican_carsGreenPedWait(Pelican * const me) {
FILE: doxygen/snippets/qfn_armx.c
function QState (line 2) | QState Pelican_carsGreen(Pelican * const me) {
function QState (line 31) | QState Pelican_carsGreen(Pelican * const me) {
FILE: doxygen/snippets/qfn_main.c
function int_t (line 17) | int_t main (void) {
FILE: doxygen/snippets/qfn_post.c
function __interrupt (line 3) | __interrupt void TIMER0_A0_ISR(void) {
function QState (line 17) | static QState Ship_flying(Ship * const me) {
FILE: doxygen/snippets/qfn_postx.c
function SysTick_Handler (line 2) | void SysTick_Handler(void) {
function QState (line 13) | static QState Ship_flying(Ship * const me) {
FILE: doxygen/snippets/qfn_qactive.c
type Pelican (line 2) | typedef struct {
function Pelican_ctor (line 8) | void Pelican_ctor(Pelican * const me, uint8_t timeout) {
FILE: doxygen/snippets/qfn_tickx.c
function __interrupt (line 3) | __interrupt void timerA_ISR(void) {
function __interrupt (line 10) | __interrupt void timerA_ISR(void) {
FILE: doxygen/snippets/qkn_lock.c
function BSP_random (line 1) | uint32_t BSP_random(void) { /* a very cheap pseudo-random-number generat...
FILE: doxygen/snippets/qkn_oncontextsw.c
function QK_onContextSw (line 3) | void QK_onContextSw(uint_fast8_t prev, uint_fast8_t next) {
FILE: examples/arm-cm/blinky_efm32-slstk3401a/blinky.c
type Blinky (line 41) | typedef struct BlinkyTag { /* the Blinky active object */
function Blinky_ctor (line 54) | void Blinky_ctor(void) {
function QState (line 60) | QState Blinky_initial(Blinky * const me) {
function QState (line 66) | QState Blinky_off(Blinky * const me) {
function QState (line 86) | QState Blinky_on(Blinky * const me) {
FILE: examples/arm-cm/blinky_efm32-slstk3401a/blinky.h
type BlinkySignals (line 37) | enum BlinkySignals {
type BlinkyTag (line 47) | struct BlinkyTag
FILE: examples/arm-cm/blinky_efm32-slstk3401a/main.c
function main (line 48) | int main(void) {
FILE: examples/arm-cm/blinky_efm32-slstk3401a/qk/bsp.c
type KernelUnawareISRs (line 49) | enum KernelUnawareISRs { /* see NOTE00 */
type KernelAwareISRs (line 56) | enum KernelAwareISRs {
function SysTick_Handler (line 78) | void SysTick_Handler(void) {
function BSP_init (line 86) | void BSP_init(void) {
function BSP_ledOff (line 135) | void BSP_ledOff(void) {
function BSP_ledOn (line 140) | void BSP_ledOn(void) {
function QF_onStartup (line 151) | void QF_onStartup(void) {
function QK_onIdle (line 170) | void QK_onIdle(void) {
function Q_NORETURN (line 187) | Q_NORETURN Q_onAssert(char const Q_ROM * const module, int loc) {
FILE: examples/arm-cm/blinky_efm32-slstk3401a/qv/bsp.c
type KernelUnawareISRs (line 49) | enum KernelUnawareISRs { /* see NOTE00 */
type KernelAwareISRs (line 56) | enum KernelAwareISRs {
function SysTick_Handler (line 79) | void SysTick_Handler(void) {
function BSP_init (line 85) | void BSP_init(void) {
function BSP_ledOff (line 120) | void BSP_ledOff(void) {
function BSP_ledOn (line 125) | void BSP_ledOn(void) {
function QF_onStartup (line 136) | void QF_onStartup(void) {
function QV_onIdle (line 155) | void QV_onIdle(void) { /* CATION: called with interrupts DISABLED, NOTE0...
function Q_NORETURN (line 174) | Q_NORETURN Q_onAssert(char const Q_ROM * const module, int loc) {
FILE: examples/arm-cm/blinky_ek-tm4c123gxl/blinky.c
type Blinky (line 41) | typedef struct BlinkyTag { /* the Blinky active object */
function Blinky_ctor (line 54) | void Blinky_ctor(void) {
function QState (line 60) | QState Blinky_initial(Blinky * const me) {
function QState (line 66) | QState Blinky_off(Blinky * const me) {
function QState (line 86) | QState Blinky_on(Blinky * const me) {
FILE: examples/arm-cm/blinky_ek-tm4c123gxl/blinky.h
type BlinkySignals (line 37) | enum BlinkySignals {
type BlinkyTag (line 47) | struct BlinkyTag
FILE: examples/arm-cm/blinky_ek-tm4c123gxl/main.c
function main (line 48) | int main(void) {
FILE: examples/arm-cm/blinky_ek-tm4c123gxl/qk/bsp.c
type KernelUnawareISRs (line 50) | enum KernelUnawareISRs { /* see NOTE00 */
type KernelAwareISRs (line 57) | enum KernelAwareISRs {
function SysTick_Handler (line 78) | void SysTick_Handler(void) {
function BSP_init (line 86) | void BSP_init(void) {
function BSP_ledOff (line 134) | void BSP_ledOff(void) {
function BSP_ledOn (line 138) | void BSP_ledOn(void) {
function QF_onStartup (line 148) | void QF_onStartup(void) {
function QK_onIdle (line 167) | void QK_onIdle(void) {
function Q_NORETURN (line 184) | Q_NORETURN Q_onAssert(char const Q_ROM * const module, int loc) {
FILE: examples/arm-cm/blinky_ek-tm4c123gxl/qv/bsp.c
type KernelUnawareISRs (line 50) | enum KernelUnawareISRs { /* see NOTE00 */
type KernelAwareISRs (line 57) | enum KernelAwareISRs {
function SysTick_Handler (line 78) | void SysTick_Handler(void) {
function BSP_init (line 84) | void BSP_init(void) {
function BSP_ledOff (line 118) | void BSP_ledOff(void) {
function BSP_ledOn (line 122) | void BSP_ledOn(void) {
function QF_onStartup (line 132) | void QF_onStartup(void) {
function QV_onIdle (line 151) | void QV_onIdle(void) { /* CATION: called with interrupts DISABLED, NOTE0...
function Q_NORETURN (line 168) | Q_NORETURN Q_onAssert(char const Q_ROM * const module, int loc) {
FILE: examples/arm-cm/dpp_efm32-slstk3401a/dpp.h
type DPPSignals (line 22) | enum DPPSignals {
type Philo (line 37) | struct Philo
type Philo (line 40) | struct Philo
type Philo (line 43) | struct Philo
type Philo (line 46) | struct Philo
type Philo (line 49) | struct Philo
type Table (line 52) | struct Table
FILE: examples/arm-cm/dpp_efm32-slstk3401a/main.c
function int_t (line 54) | int_t main() {
FILE: examples/arm-cm/dpp_efm32-slstk3401a/philo.c
type Philo (line 28) | typedef struct Philo {
type Philo (line 49) | struct Philo
type Philo (line 53) | struct Philo
type Philo (line 57) | struct Philo
type Philo (line 61) | struct Philo
type Philo (line 65) | struct Philo
function Philo_ctor (line 77) | void Philo_ctor(void) {
function QState (line 89) | static QState Philo_initial(Philo * const me) {
function QState (line 94) | static QState Philo_thinking(Philo * const me) {
function QState (line 129) | static QState Philo_hungry(Philo * const me) {
function QState (line 157) | static QState Philo_eating(Philo * const me) {
FILE: examples/arm-cm/dpp_efm32-slstk3401a/qk/bsp.c
type KernelUnawareISRs (line 49) | enum KernelUnawareISRs { /* see NOTE00 */
type KernelAwareISRs (line 56) | enum KernelAwareISRs {
function SysTick_Handler (line 81) | void SysTick_Handler(void) {
function GPIO_EVEN_IRQHandler (line 118) | void GPIO_EVEN_IRQHandler(void) {
function BSP_init (line 125) | void BSP_init(void) {
function BSP_displayPhilStat (line 175) | void BSP_displayPhilStat(uint8_t n, char const *stat) {
function BSP_displayPaused (line 185) | void BSP_displayPaused(uint8_t paused) {
function BSP_random (line 194) | uint32_t BSP_random(void) { /* a very cheap pseudo-random-number generat...
function BSP_randomSeed (line 213) | void BSP_randomSeed(uint32_t seed) {
function BSP_terminate (line 217) | void BSP_terminate(int16_t result) {
function QF_onStartup (line 222) | void QF_onStartup(void) {
function QK_onIdle (line 244) | void QK_onIdle(void) {
function Q_NORETURN (line 261) | Q_NORETURN Q_onAssert(char const Q_ROM * const module, int loc) {
FILE: examples/arm-cm/dpp_efm32-slstk3401a/qv/bsp.c
type KernelUnawareISRs (line 49) | enum KernelUnawareISRs { /* see NOTE00 */
type KernelAwareISRs (line 56) | enum KernelAwareISRs {
function SysTick_Handler (line 82) | void SysTick_Handler(void) {
function GPIO_EVEN_IRQHandler (line 115) | void GPIO_EVEN_IRQHandler(void) {
function BSP_init (line 120) | void BSP_init(void) {
function BSP_displayPhilStat (line 157) | void BSP_displayPhilStat(uint8_t n, char const *stat) {
function BSP_displayPaused (line 167) | void BSP_displayPaused(uint8_t paused) {
function BSP_random (line 176) | uint32_t BSP_random(void) { /* a very cheap pseudo-random-number generat...
function BSP_randomSeed (line 192) | void BSP_randomSeed(uint32_t seed) {
function BSP_terminate (line 196) | void BSP_terminate(int16_t result) {
function QF_onStartup (line 201) | void QF_onStartup(void) {
function QV_onIdle (line 223) | void QV_onIdle(void) { /* CATION: called with interrupts DISABLED, NOTE0...
function Q_NORETURN (line 242) | Q_NORETURN Q_onAssert(char const Q_ROM * const module, int loc) {
FILE: examples/arm-cm/dpp_efm32-slstk3401a/table.c
type Table (line 28) | typedef struct Table {
type Table (line 53) | struct Table
function Table_ctor (line 64) | void Table_ctor(void) {
function QState (line 78) | static QState Table_initial(Table * const me) {
function QState (line 89) | static QState Table_active(Table * const me) {
function QState (line 112) | static QState Table_serving(Table * const me) {
function QState (line 221) | static QState Table_paused(Table * const me) {
FILE: examples/arm-cm/dpp_efm32-slstk3401a/win32-gui/bsp.c
function DWORD (line 61) | static DWORD WINAPI appThread(LPVOID par) {
function WinMain (line 67) | int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInst,
function LRESULT (line 98) | static LRESULT CALLBACK WndProc(HWND hWnd, UINT iMsg,
function QF_onStartup (line 201) | void QF_onStartup(void) {
function QF_onCleanup (line 205) | void QF_onCleanup(void) {
function QF_onClockTickISR (line 208) | void QF_onClockTickISR(void) {
function Q_NORETURN (line 213) | Q_NORETURN Q_onAssert(char const * const module, int_t loc) {
function BSP_init (line 225) | void BSP_init(void) {
function BSP_terminate (line 228) | void BSP_terminate(int16_t result) {
function BSP_displayPhilStat (line 239) | void BSP_displayPhilStat(uint8_t n, char const *stat) {
function BSP_displayPaused (line 254) | void BSP_displayPaused(uint8_t paused) {
function BSP_random (line 261) | uint32_t BSP_random(void) { /* a very cheap pseudo-random-number genera...
function BSP_randomSeed (line 269) | void BSP_randomSeed(uint32_t seed) {
FILE: examples/arm-cm/dpp_ek-tm4c123gxl/dpp.h
type DPPSignals (line 22) | enum DPPSignals {
type Philo (line 37) | struct Philo
type Philo (line 40) | struct Philo
type Philo (line 43) | struct Philo
type Philo (line 46) | struct Philo
type Philo (line 49) | struct Philo
type Table (line 52) | struct Table
FILE: examples/arm-cm/dpp_ek-tm4c123gxl/main.c
function int_t (line 54) | int_t main() {
FILE: examples/arm-cm/dpp_ek-tm4c123gxl/philo.c
type Philo (line 28) | typedef struct Philo {
type Philo (line 49) | struct Philo
type Philo (line 53) | struct Philo
type Philo (line 57) | struct Philo
type Philo (line 61) | struct Philo
type Philo (line 65) | struct Philo
function Philo_ctor (line 77) | void Philo_ctor(void) {
function QState (line 89) | static QState Philo_initial(Philo * const me) {
function QState (line 94) | static QState Philo_thinking(Philo * const me) {
function QState (line 129) | static QState Philo_hungry(Philo * const me) {
function QState (line 157) | static QState Philo_eating(Philo * const me) {
FILE: examples/arm-cm/dpp_ek-tm4c123gxl/qk/bsp.c
type KernelUnawareISRs (line 50) | enum KernelUnawareISRs { /* see NOTE00 */
type KernelAwareISRs (line 57) | enum KernelAwareISRs {
function SysTick_Handler (line 83) | void SysTick_Handler(void) {
function GPIOPortA_IRQHandler (line 118) | void GPIOPortA_IRQHandler(void) {
function BSP_init (line 126) | void BSP_init(void) {
function BSP_displayPhilStat (line 176) | void BSP_displayPhilStat(uint8_t n, char const *stat) {
function BSP_displayPaused (line 181) | void BSP_displayPaused(uint8_t paused) {
function BSP_random (line 185) | uint32_t BSP_random(void) { /* a very cheap pseudo-random-number generat...
function BSP_randomSeed (line 204) | void BSP_randomSeed(uint32_t seed) {
function BSP_terminate (line 208) | void BSP_terminate(int16_t result) {
function QF_onStartup (line 214) | void QF_onStartup(void) {
function QK_onContextSw (line 238) | void QK_onContextSw(uint_fast8_t prev, uint_fast8_t next) {
function QK_onIdle (line 246) | void QK_onIdle(void) {
function Q_NORETURN (line 263) | Q_NORETURN Q_onAssert(char const Q_ROM * const module, int loc) {
FILE: examples/arm-cm/dpp_ek-tm4c123gxl/qv/bsp.c
type KernelUnawareISRs (line 50) | enum KernelUnawareISRs { /* see NOTE00 */
type KernelAwareISRs (line 57) | enum KernelAwareISRs {
function SysTick_Handler (line 83) | void SysTick_Handler(void) {
function GPIOPortA_IRQHandler (line 115) | void GPIOPortA_IRQHandler(void) {
function BSP_init (line 121) | void BSP_init(void) {
function BSP_displayPhilStat (line 157) | void BSP_displayPhilStat(uint8_t n, char const *stat) {
function BSP_displayPaused (line 162) | void BSP_displayPaused(uint8_t paused) {
function BSP_random (line 166) | uint32_t BSP_random(void) { /* a very cheap pseudo-random-number generat...
function BSP_randomSeed (line 179) | void BSP_randomSeed(uint32_t seed) {
function BSP_terminate (line 183) | void BSP_terminate(int16_t result) {
function QF_onStartup (line 189) | void QF_onStartup(void) {
function QV_onIdle (line 210) | void QV_onIdle(void) { /* called with interrupts disabled, see NOTE01 */
function Q_NORETURN (line 227) | Q_NORETURN Q_onAssert(char const Q_ROM * const module, int loc) {
FILE: examples/arm-cm/dpp_ek-tm4c123gxl/table.c
type Table (line 28) | typedef struct Table {
type Table (line 53) | struct Table
function Table_ctor (line 64) | void Table_ctor(void) {
function QState (line 78) | static QState Table_initial(Table * const me) {
function QState (line 89) | static QState Table_active(Table * const me) {
function QState (line 112) | static QState Table_serving(Table * const me) {
function QState (line 221) | static QState Table_paused(Table * const me) {
FILE: examples/arm-cm/dpp_mbed-lpc1768/dpp.h
type DPPSignals (line 22) | enum DPPSignals {
type Philo (line 37) | struct Philo
type Philo (line 40) | struct Philo
type Philo (line 43) | struct Philo
type Philo (line 46) | struct Philo
type Philo (line 49) | struct Philo
type Table (line 52) | struct Table
FILE: examples/arm-cm/dpp_mbed-lpc1768/main.c
function int_t (line 54) | int_t main() {
FILE: examples/arm-cm/dpp_mbed-lpc1768/philo.c
type Philo (line 28) | typedef struct Philo {
type Philo (line 49) | struct Philo
type Philo (line 53) | struct Philo
type Philo (line 57) | struct Philo
type Philo (line 61) | struct Philo
type Philo (line 65) | struct Philo
function Philo_ctor (line 77) | void Philo_ctor(void) {
function QState (line 89) | static QState Philo_initial(Philo * const me) {
function QState (line 94) | static QState Philo_thinking(Philo * const me) {
function QState (line 129) | static QState Philo_hungry(Philo * const me) {
function QState (line 157) | static QState Philo_eating(Philo * const me) {
FILE: examples/arm-cm/dpp_mbed-lpc1768/qk/bsp.c
type KernelUnawareISRs (line 47) | enum KernelUnawareISRs { /* see NOTE00 */
type KernelAwareISRs (line 54) | enum KernelAwareISRs {
function SysTick_Handler (line 82) | void SysTick_Handler(void) {
function EINT0_IRQHandler (line 118) | void EINT0_IRQHandler(void) {
function BSP_init (line 126) | void BSP_init(void) {
function BSP_displayPhilStat (line 154) | void BSP_displayPhilStat(uint8_t n, char const *stat) {
function BSP_displayPaused (line 169) | void BSP_displayPaused(uint8_t paused) {
function BSP_random (line 178) | uint32_t BSP_random(void) { /* a very cheap pseudo-random-number generat...
function BSP_randomSeed (line 187) | void BSP_randomSeed(uint32_t seed) {
function BSP_terminate (line 191) | void BSP_terminate(int16_t result) {
function QF_onStartup (line 197) | void QF_onStartup(void) {
function QK_onIdle (line 218) | void QK_onIdle(void) {
function Q_NORETURN (line 239) | Q_NORETURN Q_onAssert(char const Q_ROM * const module, int loc) {
FILE: examples/arm-cm/dpp_mbed-lpc1768/qv/bsp.c
type KernelUnawareISRs (line 47) | enum KernelUnawareISRs { /* see NOTE00 */
type KernelAwareISRs (line 54) | enum KernelAwareISRs {
function SysTick_Handler (line 82) | void SysTick_Handler(void) {
function EINT0_IRQHandler (line 114) | void EINT0_IRQHandler(void) {
function BSP_init (line 120) | void BSP_init(void) {
function BSP_displayPhilStat (line 148) | void BSP_displayPhilStat(uint8_t n, char const *stat) {
function BSP_displayPaused (line 163) | void BSP_displayPaused(uint8_t paused) {
function BSP_random (line 172) | uint32_t BSP_random(void) { /* a very cheap pseudo-random-number generat...
function BSP_randomSeed (line 181) | void BSP_randomSeed(uint32_t seed) {
function BSP_terminate (line 185) | void BSP_terminate(int16_t result) {
function QF_onStartup (line 191) | void QF_onStartup(void) {
function QV_onIdle (line 212) | void QV_onIdle(void) { /* called with interrupts disabled, see NOTE01 */
function Q_NORETURN (line 234) | Q_NORETURN Q_onAssert(char const Q_ROM * const module, int loc) {
FILE: examples/arm-cm/dpp_mbed-lpc1768/table.c
type Table (line 28) | typedef struct Table {
type Table (line 53) | struct Table
function Table_ctor (line 64) | void Table_ctor(void) {
function QState (line 78) | static QState Table_initial(Table * const me) {
function QState (line 89) | static QState Table_active(Table * const me) {
function QState (line 112) | static QState Table_serving(Table * const me) {
function QState (line 221) | static QState Table_paused(Table * const me) {
FILE: examples/arm-cm/dpp_nucleo-l053r8/dpp.h
type DPPSignals (line 22) | enum DPPSignals {
type Philo (line 37) | struct Philo
type Philo (line 40) | struct Philo
type Philo (line 43) | struct Philo
type Philo (line 46) | struct Philo
type Philo (line 49) | struct Philo
type Table (line 52) | struct Table
FILE: examples/arm-cm/dpp_nucleo-l053r8/main.c
function int_t (line 54) | int_t main() {
FILE: examples/arm-cm/dpp_nucleo-l053r8/philo.c
type Philo (line 28) | typedef struct Philo {
type Philo (line 49) | struct Philo
type Philo (line 53) | struct Philo
type Philo (line 57) | struct Philo
type Philo (line 61) | struct Philo
type Philo (line 65) | struct Philo
function Philo_ctor (line 77) | void Philo_ctor(void) {
function QState (line 89) | static QState Philo_initial(Philo * const me) {
function QState (line 94) | static QState Philo_thinking(Philo * const me) {
function QState (line 129) | static QState Philo_hungry(Philo * const me) {
function QState (line 157) | static QState Philo_eating(Philo * const me) {
FILE: examples/arm-cm/dpp_nucleo-l053r8/qk/bsp.c
type KernelAwareISRs (line 47) | enum KernelAwareISRs {
function SysTick_Handler (line 71) | void SysTick_Handler(void) {
function BSP_init (line 109) | void BSP_init(void) {
function BSP_displayPhilStat (line 138) | void BSP_displayPhilStat(uint8_t n, char const *stat) {
function BSP_displayPaused (line 147) | void BSP_displayPaused(uint8_t paused) {
function BSP_random (line 157) | uint32_t BSP_random(void) { /* a very cheap pseudo-random-number generat...
function BSP_randomSeed (line 166) | void BSP_randomSeed(uint32_t seed) {
function BSP_terminate (line 170) | void BSP_terminate(int16_t result) {
function QF_onStartup (line 176) | void QF_onStartup(void) {
function QK_onContextSw (line 195) | void QK_onContextSw(uint_fast8_t prev, uint_fast8_t next) {
function QK_onIdle (line 203) | void QK_onIdle(void) {
function Q_NORETURN (line 231) | Q_NORETURN Q_onAssert(char const Q_ROM * const module, int loc) {
FILE: examples/arm-cm/dpp_nucleo-l053r8/qv/bsp.c
type KernelAwareISRs (line 47) | enum KernelAwareISRs {
function SysTick_Handler (line 71) | void SysTick_Handler(void) {
function BSP_init (line 105) | void BSP_init(void) {
function BSP_displayPhilStat (line 134) | void BSP_displayPhilStat(uint8_t n, char const *stat) {
function BSP_displayPaused (line 143) | void BSP_displayPaused(uint8_t paused) {
function BSP_random (line 153) | uint32_t BSP_random(void) { /* a very cheap pseudo-random-number generat...
function BSP_randomSeed (line 162) | void BSP_randomSeed(uint32_t seed) {
function BSP_terminate (line 166) | void BSP_terminate(int16_t result) {
function QF_onStartup (line 172) | void QF_onStartup(void) {
function QV_onIdle (line 188) | void QV_onIdle(void) { /* called with interrupts disabled, see NOTE1 */
function Q_NORETURN (line 218) | Q_NORETURN Q_onAssert(char const Q_ROM * const module, int loc) {
FILE: examples/arm-cm/dpp_nucleo-l053r8/table.c
type Table (line 28) | typedef struct Table {
type Table (line 53) | struct Table
function Table_ctor (line 64) | void Table_ctor(void) {
function QState (line 78) | static QState Table_initial(Table * const me) {
function QState (line 89) | static QState Table_active(Table * const me) {
function QState (line 112) | static QState Table_serving(Table * const me) {
function QState (line 221) | static QState Table_paused(Table * const me) {
FILE: examples/arm-cm/dpp_nucleo-l152re/dpp.h
type DPPSignals (line 22) | enum DPPSignals {
type Philo (line 37) | struct Philo
type Philo (line 40) | struct Philo
type Philo (line 43) | struct Philo
type Philo (line 46) | struct Philo
type Philo (line 49) | struct Philo
type Table (line 52) | struct Table
FILE: examples/arm-cm/dpp_nucleo-l152re/main.c
function int_t (line 54) | int_t main() {
FILE: examples/arm-cm/dpp_nucleo-l152re/philo.c
type Philo (line 28) | typedef struct Philo {
type Philo (line 49) | struct Philo
type Philo (line 53) | struct Philo
type Philo (line 57) | struct Philo
type Philo (line 61) | struct Philo
type Philo (line 65) | struct Philo
function Philo_ctor (line 77) | void Philo_ctor(void) {
function QState (line 89) | static QState Philo_initial(Philo * const me) {
function QState (line 94) | static QState Philo_thinking(Philo * const me) {
function QState (line 129) | static QState Philo_hungry(Philo * const me) {
function QState (line 157) | static QState Philo_eating(Philo * const me) {
FILE: examples/arm-cm/dpp_nucleo-l152re/qk/bsp.c
type KernelUnawareISRs (line 47) | enum KernelUnawareISRs { /* see NOTE00 */
type KernelAwareISRs (line 54) | enum KernelAwareISRs {
function SysTick_Handler (line 78) | void SysTick_Handler(void) {
function BSP_init (line 116) | void BSP_init(void) {
function BSP_displayPhilStat (line 145) | void BSP_displayPhilStat(uint8_t n, char const *stat) {
function BSP_displayPaused (line 154) | void BSP_displayPaused(uint8_t paused) {
function BSP_random (line 164) | uint32_t BSP_random(void) { /* a very cheap pseudo-random-number generat...
function BSP_randomSeed (line 173) | void BSP_randomSeed(uint32_t seed) {
function BSP_terminate (line 177) | void BSP_terminate(int16_t result) {
function QF_onStartup (line 183) | void QF_onStartup(void) {
function QK_onIdle (line 199) | void QK_onIdle(void) {
function Q_NORETURN (line 227) | Q_NORETURN Q_onAssert(char const Q_ROM * const module, int loc) {
FILE: examples/arm-cm/dpp_nucleo-l152re/qv/bsp.c
type KernelUnawareISRs (line 47) | enum KernelUnawareISRs { /* see NOTE00 */
type KernelAwareISRs (line 54) | enum KernelAwareISRs {
function SysTick_Handler (line 78) | void SysTick_Handler(void) {
function BSP_init (line 112) | void BSP_init(void) {
function BSP_displayPhilStat (line 141) | void BSP_displayPhilStat(uint8_t n, char const *stat) {
function BSP_displayPaused (line 150) | void BSP_displayPaused(uint8_t paused) {
function BSP_random (line 160) | uint32_t BSP_random(void) { /* a very cheap pseudo-random-number generat...
function BSP_randomSeed (line 169) | void BSP_randomSeed(uint32_t seed) {
function BSP_terminate (line 173) | void BSP_terminate(int16_t result) {
function QF_onStartup (line 179) | void QF_onStartup(void) {
function QV_onIdle (line 195) | void QV_onIdle(void) { /* called with interrupts disabled, see NOTE01 */
function Q_NORETURN (line 225) | Q_NORETURN Q_onAssert(char const Q_ROM * const module, int loc) {
FILE: examples/arm-cm/dpp_nucleo-l152re/table.c
type Table (line 28) | typedef struct Table {
type Table (line 53) | struct Table
function Table_ctor (line 64) | void Table_ctor(void) {
function QState (line 78) | static QState Table_initial(Table * const me) {
function QState (line 89) | static QState Table_active(Table * const me) {
function QState (line 112) | static QState Table_serving(Table * const me) {
function QState (line 221) | static QState Table_paused(Table * const me) {
FILE: examples/arm-cm/game_efm32-slstk3401a/game.h
type GameSignals (line 22) | enum GameSignals { /* signals used in the game */
type Tunnel (line 44) | struct Tunnel
type Ship (line 45) | struct Ship
type Missile (line 46) | struct Missile
type GameBitmapIds (line 73) | enum GameBitmapIds {
FILE: examples/arm-cm/game_efm32-slstk3401a/main.c
function int_t (line 52) | int_t main() {
FILE: examples/arm-cm/game_efm32-slstk3401a/mine1.c
type Mine1 (line 28) | typedef struct Mine1 {
function QHsm (line 61) | QHsm * Mine1_ctor(uint8_t id) {
function QState (line 73) | static QState Mine1_initial(Mine1 * const me) {
function QState (line 78) | static QState Mine1_unused(Mine1 * const me) {
function QState (line 96) | static QState Mine1_used(Mine1 * const me) {
function QState (line 119) | static QState Mine1_planted(Mine1 * const me) {
function QState (line 184) | static QState Mine1_exploding(Mine1 * const me) {
FILE: examples/arm-cm/game_efm32-slstk3401a/mine2.c
type Mine2 (line 28) | typedef struct Mine2 {
function QHsm (line 61) | QHsm * Mine2_ctor(uint8_t id) {
function QState (line 73) | static QState Mine2_initial(Mine2 * const me) {
function QState (line 78) | static QState Mine2_unused(Mine2 * const me) {
function QState (line 96) | static QState Mine2_used(Mine2 * const me) {
function QState (line 119) | static QState Mine2_planted(Mine2 * const me) {
function QState (line 187) | static QState Mine2_exploding(Mine2 * const me) {
FILE: examples/arm-cm/game_efm32-slstk3401a/missile.c
type Missile (line 28) | typedef struct Missile {
function Missile_ctor (line 60) | void Missile_ctor(uint8_t speed) {
function QState (line 69) | static QState Missile_initial(Missile * const me) {
function QState (line 74) | static QState Missile_armed(Missile * const me) {
function QState (line 92) | static QState Missile_flying(Missile * const me) {
function QState (line 134) | static QState Missile_exploding(Missile * const me) {
FILE: examples/arm-cm/game_efm32-slstk3401a/qk/bsp.c
function Q_DEFINE_THIS_FILE (line 46) | Q_DEFINE_THIS_FILE
FILE: examples/arm-cm/game_efm32-slstk3401a/qv/bsp.c
function Q_DEFINE_THIS_FILE (line 46) | Q_DEFINE_THIS_FILE
FILE: examples/arm-cm/game_efm32-slstk3401a/ship.c
type Ship (line 31) | typedef struct Ship {
function Ship_ctor (line 62) | void Ship_ctor(void) {
function QState (line 72) | static QState Ship_initial(Ship * const me) {
function QState (line 77) | static QState Ship_active(Ship * const me) {
function QState (line 93) | static QState Ship_parked(Ship * const me) {
function QState (line 109) | static QState Ship_flying(Ship * const me) {
function QState (line 183) | static QState Ship_exploding(Ship * const me) {
FILE: examples/arm-cm/game_efm32-slstk3401a/tunnel.c
type Tunnel (line 28) | typedef struct Tunnel {
function Tunnel_ctor (line 74) | void Tunnel_ctor(void) {
function Tunnel_advance (line 90) | static void Tunnel_advance(Tunnel * const me) {
function Tunnel_plantMine (line 132) | static void Tunnel_plantMine(Tunnel * const me) {
function Tunnel_dispatchToAllMines (line 175) | static void Tunnel_dispatchToAllMines(Tunnel * const me, QSignal sig, QP...
function QState (line 188) | static QState Tunnel_initial(Tunnel * const me) {
function QState (line 199) | static QState Tunnel_active(Tunnel * const me) {
function QState (line 223) | static QState Tunnel_show_logo(Tunnel * const me) {
function QState (line 281) | static QState Tunnel_demo(Tunnel * const me) {
function QState (line 346) | static QState Tunnel_playing(Tunnel * const me) {
function QState (line 448) | static QState Tunnel_game_over(Tunnel * const me) {
function QState (line 496) | static QState Tunnel_screen_saver(Tunnel * const me) {
function QState (line 517) | static QState Tunnel_screen_saver_hide(Tunnel * const me) {
function QState (line 547) | static QState Tunnel_screen_saver_show(Tunnel * const me) {
function QState (line 584) | static QState Tunnel_final(Tunnel * const me) {
FILE: examples/arm-cm/game_efm32-slstk3401a/win32-gui/bsp.c
function playerTrigger (line 77) | static void playerTrigger(void) {
function BSP_init (line 83) | void BSP_init(void) {
function BSP_terminate (line 86) | void BSP_terminate(int16_t result) {
function BSP_updateScreen (line 101) | void BSP_updateScreen(void) {
function BSP_clearFB (line 126) | void BSP_clearFB() {
function BSP_clearWalls (line 136) | void BSP_clearWalls() {
function BSP_isThrottle (line 146) | bool BSP_isThrottle(void) { /* is the throttle button depressed? */
function BSP_paintString (line 150) | void BSP_paintString(uint8_t x, uint8_t y, char const *str) {
type Bitmap (line 256) | typedef struct { /* the auxiliary structure to hold const bitmaps */
function BSP_paintBitmap (line 378) | void BSP_paintBitmap(uint8_t x, uint8_t y, uint8_t bmp_id) {
function BSP_advanceWalls (line 383) | void BSP_advanceWalls(uint8_t top, uint8_t bottom) {
function BSP_doBitmapsOverlap (line 408) | bool BSP_doBitmapsOverlap(uint8_t bmp_id1, uint8_t x1, uint8_t y1,
function BSP_isWallHit (line 472) | bool BSP_isWallHit(uint8_t bmp_id, uint8_t x, uint8_t y) {
function BSP_updateScore (line 490) | void BSP_updateScore(uint16_t score) {
function BSP_displayOn (line 518) | void BSP_displayOn(void) {
function BSP_displayOff (line 522) | void BSP_displayOff(void) {
function BSP_random (line 528) | uint32_t BSP_random(void) { /* a very cheap pseudo-random-number genera...
function BSP_randomSeed (line 536) | void BSP_randomSeed(uint32_t seed) {
function QF_onStartup (line 541) | void QF_onStartup(void) {
function QF_onCleanup (line 545) | void QF_onCleanup(void) {
function QF_onClockTickISR (line 548) | void QF_onClockTickISR(void) {
function Q_NORETURN (line 558) | Q_NORETURN Q_onAssert(char const * const module, int_t loc) {
function paintBits (line 570) | static void paintBits(uint8_t x, uint8_t y, uint8_t const *bits, uint8_t...
function paintBitsClear (line 581) | static void paintBitsClear(uint8_t x, uint8_t y,
function DWORD (line 602) | static DWORD WINAPI appThread(LPVOID par) {
function WinMain (line 608) | int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInst,
function LRESULT (line 639) | static LRESULT CALLBACK WndProc(HWND hWnd, UINT iMsg,
FILE: examples/arm-cm/pelican_ek-tm4c123gxl/bsp.h
type BSP_CarsSignal (line 39) | enum BSP_CarsSignal {
type BSP_PedsSignal (line 43) | enum BSP_PedsSignal {
type BSP_CarsSignal (line 49) | enum BSP_CarsSignal
type BSP_PedsSignal (line 50) | enum BSP_PedsSignal
FILE: examples/arm-cm/pelican_ek-tm4c123gxl/main.c
function main (line 48) | int main (void) {
FILE: examples/arm-cm/pelican_ek-tm4c123gxl/pelican.c
type Pelican (line 35) | typedef struct Pelican {
type Pelican (line 59) | struct Pelican
function Pelican_ctor (line 70) | void Pelican_ctor(void) {
function QState (line 77) | static QState Pelican_initial(Pelican * const me) {
function QState (line 82) | static QState Pelican_operational(Pelican * const me) {
function QState (line 116) | static QState Pelican_carsEnabled(Pelican * const me) {
function QState (line 138) | static QState Pelican_carsGreen(Pelican * const me) {
function QState (line 168) | static QState Pelican_carsGreenNoPed(Pelican * const me) {
function QState (line 195) | static QState Pelican_carsGreenInt(Pelican * const me) {
function QState (line 217) | static QState Pelican_carsGreenPedWait(Pelican * const me) {
function QState (line 239) | static QState Pelican_carsYellow(Pelican * const me) {
function QState (line 271) | static QState Pelican_pedsEnabled(Pelican * const me) {
function QState (line 293) | static QState Pelican_pedsWalk(Pelican * const me) {
function QState (line 324) | static QState Pelican_pedsFlash(Pelican * const me) {
function QState (line 372) | static QState Pelican_offline(Pelican * const me) {
FILE: examples/arm-cm/pelican_ek-tm4c123gxl/pelican.h
type PelicanSignals (line 22) | enum PelicanSignals {
type Pelican (line 35) | struct Pelican
FILE: examples/arm-cm/pelican_ek-tm4c123gxl/qk/bsp.c
type KernelUnawareISRs (line 50) | enum KernelUnawareISRs { /* see NOTE00 */
type KernelAwareISRs (line 57) | enum KernelAwareISRs {
function SysTick_Handler (line 78) | void SysTick_Handler(void) {
function BSP_init (line 114) | void BSP_init(void) {
function BSP_showState (line 148) | void BSP_showState(char_t const *state) {
function BSP_signalCars (line 152) | void BSP_signalCars(enum BSP_CarsSignal sig) {
function BSP_signalPeds (line 173) | void BSP_signalPeds(enum BSP_PedsSignal sig) {
function QF_onStartup (line 192) | void QF_onStartup(void) {
function QF_stop (line 211) | void QF_stop(void) {
function QK_onIdle (line 214) | void QK_onIdle(void) {
function Q_NORETURN (line 231) | Q_NORETURN Q_onAssert(char const Q_ROM * const module, int loc) {
FILE: examples/arm-cm/pelican_ek-tm4c123gxl/qv/bsp.c
type KernelUnawareISRs (line 50) | enum KernelUnawareISRs { /* see NOTE00 */
type KernelAwareISRs (line 57) | enum KernelAwareISRs {
function SysTick_Handler (line 78) | void SysTick_Handler(void) {
function BSP_init (line 110) | void BSP_init(void) {
function BSP_showState (line 144) | void BSP_showState(char_t const *state) {
function BSP_signalCars (line 148) | void BSP_signalCars(enum BSP_CarsSignal sig) {
function BSP_signalPeds (line 169) | void BSP_signalPeds(enum BSP_PedsSignal sig) {
function QF_onStartup (line 188) | void QF_onStartup(void) {
function QF_stop (line 207) | void QF_stop(void) {
function QV_onIdle (line 210) | void QV_onIdle(void) { /* CATION: called with interrupts DISABLED, NOTE0...
function Q_NORETURN (line 227) | Q_NORETURN Q_onAssert(char const Q_ROM * const module, int loc) {
FILE: examples/arm7-9/dpp_at91sam7s-ek/dpp.h
type DPPSignals (line 22) | enum DPPSignals {
type Philo (line 37) | struct Philo
type Philo (line 40) | struct Philo
type Philo (line 43) | struct Philo
type Philo (line 46) | struct Philo
type Philo (line 49) | struct Philo
type Table (line 52) | struct Table
FILE: examples/arm7-9/dpp_at91sam7s-ek/main.c
function int_t (line 54) | int_t main() {
FILE: examples/arm7-9/dpp_at91sam7s-ek/philo.c
type Philo (line 28) | typedef struct Philo {
type Philo (line 49) | struct Philo
type Philo (line 53) | struct Philo
type Philo (line 57) | struct Philo
type Philo (line 61) | struct Philo
type Philo (line 65) | struct Philo
function Philo_ctor (line 77) | void Philo_ctor(void) {
function QState (line 89) | static QState Philo_initial(Philo * const me) {
function QState (line 94) | static QState Philo_thinking(Philo * const me) {
function QState (line 129) | static QState Philo_hungry(Philo * const me) {
function QState (line 157) | static QState Philo_eating(Philo * const me) {
FILE: examples/arm7-9/dpp_at91sam7s-ek/qk/iar/bsp.c
function __ramfunc (line 71) | __ramfunc
function __ramfunc (line 83) | __ramfunc
function __ramfunc (line 118) | __ramfunc
function BSP_init (line 123) | void BSP_init(void) {
function BSP_displayPhilStat (line 162) | void BSP_displayPhilStat(uint8_t n, char const *stat) {
function BSP_displayPaused (line 177) | void BSP_displayPaused(uint8_t paused) {
function BSP_random (line 186) | uint32_t BSP_random(void) { /* a very cheap pseudo-random-number generat...
function BSP_randomSeed (line 195) | void BSP_randomSeed(uint32_t seed) {
function BSP_terminate (line 199) | void BSP_terminate(int16_t result) {
function QF_onStartup (line 205) | void QF_onStartup(void) {
function __ramfunc (line 224) | __ramfunc
function Q_NORETURN (line 239) | Q_NORETURN Q_onAssert(char const Q_ROM * const module, int loc) {
FILE: examples/arm7-9/dpp_at91sam7s-ek/qv/iar/bsp.c
function __ramfunc (line 71) | __ramfunc
function __ramfunc (line 83) | __ramfunc
function __ramfunc (line 118) | __ramfunc
function BSP_init (line 123) | void BSP_init(void) {
function BSP_displayPhilStat (line 162) | void BSP_displayPhilStat(uint8_t n, char const *stat) {
function BSP_displayPaused (line 177) | void BSP_displayPaused(uint8_t paused) {
function BSP_random (line 186) | uint32_t BSP_random(void) { /* a very cheap pseudo-random-number generat...
function BSP_randomSeed (line 195) | void BSP_randomSeed(uint32_t seed) {
function BSP_terminate (line 199) | void BSP_terminate(int16_t result) {
function QF_onStartup (line 205) | void QF_onStartup(void) {
function __ramfunc (line 224) | __ramfunc
function Q_NORETURN (line 239) | Q_NORETURN Q_onAssert(char const Q_ROM * const module, int loc) {
FILE: examples/arm7-9/dpp_at91sam7s-ek/table.c
type Table (line 28) | typedef struct Table {
type Table (line 53) | struct Table
function Table_ctor (line 64) | void Table_ctor(void) {
function QState (line 78) | static QState Table_initial(Table * const me) {
function QState (line 89) | static QState Table_active(Table * const me) {
function QState (line 112) | static QState Table_serving(Table * const me) {
function QState (line 221) | static QState Table_paused(Table * const me) {
FILE: examples/avr/blinky_arduino-uno/blinky.c
type Blinky (line 41) | typedef struct BlinkyTag { /* the Blinky active object */
function Blinky_ctor (line 54) | void Blinky_ctor(void) {
function QState (line 60) | QState Blinky_initial(Blinky * const me) {
function QState (line 66) | QState Blinky_off(Blinky * const me) {
function QState (line 86) | QState Blinky_on(Blinky * const me) {
FILE: examples/avr/blinky_arduino-uno/blinky.h
type BlinkySignals (line 37) | enum BlinkySignals {
type BlinkyTag (line 47) | struct BlinkyTag
FILE: examples/avr/blinky_arduino-uno/main.c
function main (line 48) | int main(void) {
FILE: examples/avr/blinky_arduino-uno/qk/gnu/bsp.c
function ISR (line 51) | ISR(TIMER2_COMPA_vect) {
function BSP_init (line 58) | void BSP_init(void) {
function BSP_ledOff (line 63) | void BSP_ledOff(void) {
function BSP_ledOn (line 67) | void BSP_ledOn(void) {
function BSP_terminate (line 71) | void BSP_terminate(int16_t result) {
function QF_onStartup (line 77) | void QF_onStartup(void) {
function QF_onCleanup (line 87) | void QF_onCleanup(void) {
function QK_onIdle (line 91) | void QK_onIdle(void) {
function Q_NORETURN (line 109) | Q_NORETURN Q_onAssert(char const Q_ROM * const file, int line) {
FILE: examples/avr/blinky_arduino-uno/qk/iar/bsp.c
function __interrupt (line 53) | __interrupt void timer2_ISR(void) {
function BSP_init (line 61) | void BSP_init(void) {
function BSP_ledOff (line 66) | void BSP_ledOff(void) {
function BSP_ledOn (line 70) | void BSP_ledOn(void) {
function BSP_terminate (line 74) | void BSP_terminate(int16_t result) {
function QF_onStartup (line 80) | void QF_onStartup(void) {
function QF_onCleanup (line 90) | void QF_onCleanup(void) {
function QK_onIdle (line 94) | void QK_onIdle(void) {
function Q_NORETURN (line 112) | Q_NORETURN Q_onAssert(char const Q_ROM * const file, int line) {
FILE: examples/avr/blinky_arduino-uno/qv/gnu/bsp.c
function ISR (line 51) | ISR(TIMER2_COMPA_vect) {
function BSP_init (line 56) | void BSP_init(void) {
function BSP_ledOff (line 61) | void BSP_ledOff(void) {
function BSP_ledOn (line 65) | void BSP_ledOn(void) {
function BSP_terminate (line 69) | void BSP_terminate(int16_t result) {
function QF_onStartup (line 75) | void QF_onStartup(void) {
function QF_onCleanup (line 85) | void QF_onCleanup(void) {
function QV_onIdle (line 89) | void QV_onIdle(void) { /* called with interrupts DISABLED, see NOTE1 */
function Q_NORETURN (line 106) | Q_NORETURN Q_onAssert(char const Q_ROM * const file, int line) {
FILE: examples/avr/blinky_arduino-uno/qv/iar/bsp.c
function __interrupt (line 53) | __interrupt void timer2_ISR(void) {
function BSP_init (line 58) | void BSP_init(void) {
function BSP_ledOff (line 63) | void BSP_ledOff(void) {
function BSP_ledOn (line 67) | void BSP_ledOn(void) {
function BSP_terminate (line 71) | void BSP_terminate(int16_t result) {
function QF_onStartup (line 77) | void QF_onStartup(void) {
function QF_onCleanup (line 87) | void QF_onCleanup(void) {
function QV_onIdle (line 91) | void QV_onIdle(void) { /* called with interrupts DISABLED, see NOTE1 */
function Q_NORETURN (line 108) | Q_NORETURN Q_onAssert(char const Q_ROM * const file, int line) {
FILE: examples/avr/dpp_arduino-uno/dpp.h
type DPPSignals (line 22) | enum DPPSignals {
type Philo (line 37) | struct Philo
type Philo (line 40) | struct Philo
type Philo (line 43) | struct Philo
type Philo (line 46) | struct Philo
type Philo (line 49) | struct Philo
type Table (line 52) | struct Table
FILE: examples/avr/dpp_arduino-uno/main.c
function int_t (line 54) | int_t main() {
FILE: examples/avr/dpp_arduino-uno/philo.c
type Philo (line 28) | typedef struct Philo {
type Philo (line 49) | struct Philo
type Philo (line 53) | struct Philo
type Philo (line 57) | struct Philo
type Philo (line 61) | struct Philo
type Philo (line 65) | struct Philo
function Philo_ctor (line 77) | void Philo_ctor(void) {
function QState (line 89) | static QState Philo_initial(Philo * const me) {
function QState (line 94) | static QState Philo_thinking(Philo * const me) {
function QState (line 129) | static QState Philo_hungry(Philo * const me) {
function QState (line 157) | static QState Philo_eating(Philo * const me) {
FILE: examples/avr/dpp_arduino-uno/qk/gnu/bsp.c
function ISR (line 57) | ISR(TIMER2_COMPA_vect) {
function BSP_init (line 93) | void BSP_init(void) {
function BSP_displayPhilStat (line 102) | void BSP_displayPhilStat(uint8_t n, char const *stat) {
function BSP_displayPaused (line 111) | void BSP_displayPaused(uint8_t paused) {
function BSP_random (line 121) | uint32_t BSP_random(void) { /* a very cheap pseudo-random-number generat...
function BSP_randomSeed (line 130) | void BSP_randomSeed(uint32_t seed) {
function BSP_terminate (line 134) | void BSP_terminate(int16_t result) {
function QF_onStartup (line 140) | void QF_onStartup(void) {
function QF_onCleanup (line 150) | void QF_onCleanup(void) {
function QK_onIdle (line 154) | void QK_onIdle(void) {
function Q_NORETURN (line 172) | Q_NORETURN Q_onAssert(char const Q_ROM * const module, int location) {
FILE: examples/avr/dpp_arduino-uno/qk/iar/bsp.c
function __interrupt (line 58) | __interrupt void timer2_ISR(void) {
function BSP_init (line 94) | void BSP_init(void) {
function BSP_displayPhilStat (line 103) | void BSP_displayPhilStat(uint8_t n, char const *stat) {
function BSP_displayPaused (line 112) | void BSP_displayPaused(uint8_t paused) {
function BSP_random (line 122) | uint32_t BSP_random(void) { /* a very cheap pseudo-random-number generat...
function BSP_randomSeed (line 131) | void BSP_randomSeed(uint32_t seed) {
function BSP_terminate (line 135) | void BSP_terminate(int16_t result) {
function QF_onStartup (line 141) | void QF_onStartup(void) {
function QF_onCleanup (line 151) | void QF_onCleanup(void) {
function QK_onIdle (line 155) | void QK_onIdle(void) {
function Q_NORETURN (line 173) | Q_NORETURN Q_onAssert(char const Q_ROM * const module, int location) {
FILE: examples/avr/dpp_arduino-uno/qv/gnu/bsp.c
function ISR (line 57) | ISR(TIMER2_COMPA_vect) {
function BSP_init (line 89) | void BSP_init(void) {
function BSP_displayPhilStat (line 98) | void BSP_displayPhilStat(uint8_t n, char const *stat) {
function BSP_displayPaused (line 107) | void BSP_displayPaused(uint8_t paused) {
function BSP_random (line 117) | uint32_t BSP_random(void) { /* a very cheap pseudo-random-number generat...
function BSP_randomSeed (line 126) | void BSP_randomSeed(uint32_t seed) {
function BSP_terminate (line 130) | void BSP_terminate(int16_t result) {
function QF_onStartup (line 136) | void QF_onStartup(void) {
function QF_onCleanup (line 146) | void QF_onCleanup(void) {
function QV_onIdle (line 150) | void QV_onIdle(void) { /* called with interrupts DISABLED, see NOTE1 */
function Q_NORETURN (line 168) | Q_NORETURN Q_onAssert(char const Q_ROM * const module, int location) {
FILE: examples/avr/dpp_arduino-uno/qv/iar/bsp.c
function __interrupt (line 58) | __interrupt void timer2_ISR(void) {
function BSP_init (line 90) | void BSP_init(void) {
function BSP_displayPhilStat (line 99) | void BSP_displayPhilStat(uint8_t n, char const *stat) {
function BSP_displayPaused (line 108) | void BSP_displayPaused(uint8_t paused) {
function BSP_random (line 118) | uint32_t BSP_random(void) { /* a very cheap pseudo-random-number generat...
function BSP_randomSeed (line 127) | void BSP_randomSeed(uint32_t seed) {
function BSP_terminate (line 131) | void BSP_terminate(int16_t result) {
function QF_onStartup (line 137) | void QF_onStartup(void) {
function QF_onCleanup (line 147) | void QF_onCleanup(void) {
function QV_onIdle (line 151) | void QV_onIdle(void) { /* called with interrupts DISABLED, see NOTE1 */
function Q_NORETURN (line 169) | Q_NORETURN Q_onAssert(char const Q_ROM * const module, int location) {
FILE: examples/avr/dpp_arduino-uno/table.c
type Table (line 28) | typedef struct Table {
type Table (line 53) | struct Table
function Table_ctor (line 64) | void Table_ctor(void) {
function QState (line 78) | static QState Table_initial(Table * const me) {
function QState (line 89) | static QState Table_active(Table * const me) {
function QState (line 112) | static QState Table_serving(Table * const me) {
function QState (line 221) | static QState Table_paused(Table * const me) {
FILE: examples/msp430/blinky_msp-exp430f5529lp/blinky.c
type Blinky (line 41) | typedef struct BlinkyTag { /* the Blinky active object */
function Blinky_ctor (line 54) | void Blinky_ctor(void) {
function QState (line 60) | QState Blinky_initial(Blinky * const me) {
function QState (line 66) | QState Blinky_off(Blinky * const me) {
function QState (line 86) | QState Blinky_on(Blinky * const me) {
FILE: examples/msp430/blinky_msp-exp430f5529lp/blinky.h
type BlinkySignals (line 37) | enum BlinkySignals {
type BlinkyTag (line 47) | struct BlinkyTag
FILE: examples/msp430/blinky_msp-exp430f5529lp/main.c
function main (line 48) | int main(void) {
FILE: examples/msp430/blinky_msp-exp430f5529lp/qk/bsp.c
function BSP_init (line 75) | void BSP_init(void) {
function BSP_ledOff (line 84) | void BSP_ledOff(void) {
function BSP_ledOn (line 88) | void BSP_ledOn(void) {
function QF_onStartup (line 94) | void QF_onStartup(void) {
function QK_onIdle (line 100) | void QK_onIdle(void) {
function Q_NORETURN (line 117) | Q_NORETURN Q_onAssert(char const Q_ROM * const file, int line) {
FILE: examples/msp430/blinky_msp-exp430f5529lp/qv/bsp.c
function BSP_init (line 75) | void BSP_init(void) {
function BSP_ledOff (line 84) | void BSP_ledOff(void) {
function BSP_ledOn (line 88) | void BSP_ledOn(void) {
function QF_onStartup (line 94) | void QF_onStartup(void) {
function QV_onIdle (line 100) | void QV_onIdle(void) { /* NOTE: called with interrutps DISABLED, see NOT...
function Q_NORETURN (line 117) | Q_NORETURN Q_onAssert(char const Q_ROM * const file, int line) {
FILE: examples/msp430/blinky_msp-exp430g2/blinky.c
type Blinky (line 41) | typedef struct BlinkyTag { /* the Blinky active object */
function Blinky_ctor (line 54) | void Blinky_ctor(void) {
function QState (line 60) | QState Blinky_initial(Blinky * const me) {
function QState (line 66) | QState Blinky_off(Blinky * const me) {
function QState (line 86) | QState Blinky_on(Blinky * const me) {
FILE: examples/msp430/blinky_msp-exp430g2/blinky.h
type BlinkySignals (line 37) | enum BlinkySignals {
type BlinkyTag (line 47) | struct BlinkyTag
FILE: examples/msp430/blinky_msp-exp430g2/main.c
function main (line 48) | int main(void) {
FILE: examples/msp430/blinky_msp-exp430g2/qk/bsp.c
function BSP_init (line 71) | void BSP_init(void) {
function BSP_ledOff (line 82) | void BSP_ledOff(void) {
function BSP_ledOn (line 86) | void BSP_ledOn(void) {
function QF_onStartup (line 91) | void QF_onStartup(void) {
function QK_onIdle (line 97) | void QK_onIdle(void) {
function Q_NORETURN (line 113) | Q_NORETURN Q_onAssert(char const Q_ROM * const file, int line) {
FILE: examples/msp430/blinky_msp-exp430g2/qv/bsp.c
function BSP_init (line 71) | void BSP_init(void) {
function BSP_ledOff (line 82) | void BSP_ledOff(void) {
function BSP_ledOn (line 86) | void BSP_ledOn(void) {
function QF_onStartup (line 91) | void QF_onStartup(void) {
function QV_onIdle (line 97) | void QV_onIdle(void) { /* NOTE: called with interrutps DISABLED, see NOT...
function Q_NORETURN (line 113) | Q_NORETURN Q_onAssert(char const Q_ROM * const file, int line) {
FILE: examples/msp430/dpp_msp-exp430g2/dpp.h
type DPPSignals (line 22) | enum DPPSignals {
type Philo (line 37) | struct Philo
type Philo (line 40) | struct Philo
type Philo (line 43) | struct Philo
type Philo (line 46) | struct Philo
type Philo (line 49) | struct Philo
type Table (line 52) | struct Table
FILE: examples/msp430/dpp_msp-exp430g2/main.c
function int_t (line 54) | int_t main() {
FILE: examples/msp430/dpp_msp-exp430g2/philo.c
type Philo (line 28) | typedef struct Philo {
type Philo (line 49) | struct Philo
type Philo (line 53) | struct Philo
type Philo (line 57) | struct Philo
type Philo (line 61) | struct Philo
type Philo (line 65) | struct Philo
function Philo_ctor (line 77) | void Philo_ctor(void) {
function QState (line 89) | static QState Philo_initial(Philo * const me) {
function QState (line 94) | static QState Philo_thinking(Philo * const me) {
function QState (line 129) | static QState Philo_hungry(Philo * const me) {
function QState (line 157) | static QState Philo_eating(Philo * const me) {
FILE: examples/msp430/dpp_msp-exp430g2/qk/bsp.c
type ButtonsDebouncing (line 71) | struct ButtonsDebouncing {
function BSP_init (line 107) | void BSP_init(void) {
function BSP_displayPhilStat (line 124) | void BSP_displayPhilStat(uint8_t n, char const *stat) {
function BSP_displayPaused (line 133) | void BSP_displayPaused(uint8_t paused) {
function BSP_random (line 143) | uint32_t BSP_random(void) { /* a very cheap pseudo-random-number generat...
function BSP_randomSeed (line 152) | void BSP_randomSeed(uint32_t seed) {
function BSP_terminate (line 156) | void BSP_terminate(int16_t result) {
function QF_onStartup (line 162) | void QF_onStartup(void) {
function QK_onIdle (line 168) | void QK_onIdle(void) {
function Q_NORETURN (line 184) | Q_NORETURN Q_onAssert(char const Q_ROM * const file, int line) {
FILE: examples/msp430/dpp_msp-exp430g2/qv/bsp.c
type ButtonsDebouncing (line 71) | struct ButtonsDebouncing {
function BSP_init (line 107) | void BSP_init(void) {
function BSP_displayPhilStat (line 124) | void BSP_displayPhilStat(uint8_t n, char const *stat) {
function BSP_displayPaused (line 133) | void BSP_displayPaused(uint8_t paused) {
function BSP_random (line 143) | uint32_t BSP_random(void) { /* a very cheap pseudo-random-number generat...
function BSP_randomSeed (line 152) | void BSP_randomSeed(uint32_t seed) {
function BSP_terminate (line 156) | void BSP_terminate(int16_t result) {
function QF_onStartup (line 162) | void QF_onStartup(void) {
function QV_onIdle (line 168) | void QV_onIdle(void) { /* NOTE: called with interrutps DISABLED, see NOT...
function Q_NORETURN (line 185) | Q_NORETURN Q_onAssert(char const Q_ROM * const file, int line) {
FILE: examples/msp430/dpp_msp-exp430g2/table.c
type Table (line 28) | typedef struct Table {
type Table (line 53) | struct Table
function Table_ctor (line 64) | void Table_ctor(void) {
function QState (line 78) | static QState Table_initial(Table * const me) {
function QState (line 89) | static QState Table_active(Table * const me) {
function QState (line 112) | static QState Table_serving(Table * const me) {
function QState (line 221) | static QState Table_paused(Table * const me) {
FILE: examples/pic24_dspic/blinky_microstick2-pic24/blinky.c
type Blinky (line 41) | typedef struct BlinkyTag { /* the Blinky active object */
function Blinky_ctor (line 54) | void Blinky_ctor(void) {
function QState (line 60) | QState Blinky_initial(Blinky * const me) {
function QState (line 66) | QState Blinky_off(Blinky * const me) {
function QState (line 86) | QState Blinky_on(Blinky * const me) {
FILE: examples/pic24_dspic/blinky_microstick2-pic24/blinky.h
type BlinkySignals (line 37) | enum BlinkySignals {
type BlinkyTag (line 47) | struct BlinkyTag
FILE: examples/pic24_dspic/blinky_microstick2-pic24/main.c
function main (line 48) | int main(void) {
FILE: examples/pic24_dspic/blinky_microstick2-pic24/qk/xc16/bsp.c
function _T2Interrupt (line 61) | QK_ISR(no_auto_psv) _T2Interrupt() {
function _INT0Interrupt (line 69) | QK_ISR(auto_psv) _INT0Interrupt() {
function BSP_init (line 78) | void BSP_init(void) {
function BSP_terminate (line 86) | void BSP_terminate(int16_t result) {
function BSP_ledOff (line 90) | void BSP_ledOff(void) {
function BSP_ledOn (line 94) | void BSP_ledOn(void) {
function Q_NORETURN (line 99) | Q_NORETURN Q_onAssert(char const Q_ROM * const file, int line) {
function QF_onStartup (line 108) | void QF_onStartup(void) { /* entered with interrupts locked */
function QF_onCleanup (line 125) | void QF_onCleanup(void) {
function QF_stop (line 128) | void QF_stop(void) {
function QK_onIdle (line 131) | void QK_onIdle(void) {
FILE: examples/pic24_dspic/blinky_microstick2-pic24/qv/xc16/bsp.c
function _T2Interrupt (line 61) | void __attribute__((__interrupt__, auto_psv))
function _INT0Interrupt (line 69) | void __attribute__((__interrupt__, auto_psv))
function BSP_init (line 77) | void BSP_init(void) {
function BSP_terminate (line 85) | void BSP_terminate(int16_t result) {
function BSP_ledOff (line 89) | void BSP_ledOff(void) {
function BSP_ledOn (line 93) | void BSP_ledOn(void) {
function Q_NORETURN (line 98) | Q_NORETURN Q_onAssert(char const Q_ROM * const file, int line) {
function QF_onStartup (line 107) | void QF_onStartup(void) { /* entered with interrupts locked */
function QF_onCleanup (line 124) | void QF_onCleanup(void) {
function QF_stop (line 127) | void QF_stop(void) {
function QV_onIdle (line 130) | void QV_onIdle(void) { /* entered with interrupts DISABLED, see NOTE01 */
FILE: examples/pic24_dspic/dpp_microstick2-pic24/dpp.h
type DPPSignals (line 22) | enum DPPSignals {
type Philo (line 37) | struct Philo
type Philo (line 40) | struct Philo
type Philo (line 43) | struct Philo
type Philo (line 46) | struct Philo
type Philo (line 49) | struct Philo
type Table (line 52) | struct Table
FILE: examples/pic24_dspic/dpp_microstick2-pic24/main.c
function int_t (line 54) | int_t main() {
FILE: examples/pic24_dspic/dpp_microstick2-pic24/philo.c
type Philo (line 28) | typedef struct Philo {
type Philo (line 49) | struct Philo
type Philo (line 53) | struct Philo
type Philo (line 57) | struct Philo
type Philo (line 61) | struct Philo
type Philo (line 65) | struct Philo
function Philo_ctor (line 77) | void Philo_ctor(void) {
function QState (line 89) | static QState Philo_initial(Philo * const me) {
function QState (line 94) | static QState Philo_thinking(Philo * const me) {
function QState (line 129) | static QState Philo_hungry(Philo * const me) {
function QState (line 157) | static QState Philo_eating(Philo * const me) {
FILE: examples/pic24_dspic/dpp_microstick2-pic24/qk/xc16/bsp.c
function _T2Interrupt (line 62) | QK_ISR(no_auto_psv) _T2Interrupt() {
function _INT0Interrupt (line 70) | QK_ISR(auto_psv) _INT0Interrupt() {
function BSP_init (line 79) | void BSP_init(void) {
function BSP_terminate (line 88) | void BSP_terminate(int16_t result) {
function BSP_displayPhilStat (line 92) | void BSP_displayPhilStat(uint8_t n, char const Q_ROM *stat) {
function BSP_displayPaused (line 98) | void BSP_displayPaused(uint8_t paused) {
function BSP_random (line 102) | uint32_t BSP_random(void) { /* a very cheap pseudo-random-number genera...
function BSP_randomSeed (line 110) | void BSP_randomSeed(uint32_t seed) {
function Q_NORETURN (line 115) | Q_NORETURN Q_onAssert(char const Q_ROM * const file, int line) {
function QF_onStartup (line 124) | void QF_onStartup(void) { /* entered with interrupts locked */
function QF_onCleanup (line 141) | void QF_onCleanup(void) {
function QK_onIdle (line 144) | void QK_onIdle(void) {
FILE: examples/pic24_dspic/dpp_microstick2-pic24/qv/xc16/bsp.c
function _T2Interrupt (line 62) | void __attribute__((__interrupt__, auto_psv))
function _INT0Interrupt (line 70) | void __attribute__((__interrupt__, auto_psv))
function BSP_init (line 78) | void BSP_init(void) {
function BSP_terminate (line 87) | void BSP_terminate(int16_t result) {
function BSP_displayPhilStat (line 91) | void BSP_displayPhilStat(uint8_t n, char const Q_ROM *stat) {
function BSP_displayPaused (line 97) | void BSP_displayPaused(uint8_t paused) {
function BSP_random (line 101) | uint32_t BSP_random(void) { /* a very cheap pseudo-random-number genera...
function BSP_randomSeed (line 109) | void BSP_randomSeed(uint32_t seed) {
function Q_NORETURN (line 114) | Q_NORETURN Q_onAssert(char const Q_ROM * const file, int line) {
function QF_onStartup (line 123) | void QF_onStartup(void) { /* entered with interrupts locked */
function QF_onCleanup (line 140) | void QF_onCleanup(void) {
function QV_onIdle (line 143) | void QV_onIdle(void) { /* entered with interrupts DISABLED, see NOTE01 */
FILE: examples/pic24_dspic/dpp_microstick2-pic24/table.c
type Table (line 28) | typedef struct Table {
type Table (line 53) | struct Table
function Table_ctor (line 64) | void Table_ctor(void) {
function QState (line 78) | static QState Table_initial(Table * const me) {
function QState (line 89) | static QState Table_active(Table * const me) {
function QState (line 112) | static QState Table_serving(Table * const me) {
function QState (line 221) | static QState Table_paused(Table * const me) {
FILE: examples/pic24_dspic/pelican_microstick2-pic24/bsp.h
type BSP_CarsSignal (line 39) | enum BSP_CarsSignal {
type BSP_PedsSignal (line 43) | enum BSP_PedsSignal {
type BSP_CarsSignal (line 49) | enum BSP_CarsSignal
type BSP_PedsSignal (line 50) | enum BSP_PedsSignal
FILE: examples/pic24_dspic/pelican_microstick2-pic24/main.c
function main (line 48) | int main (void) {
FILE: examples/pic24_dspic/pelican_microstick2-pic24/pelican.c
type Pelican (line 35) | typedef struct Pelican {
type Pelican (line 59) | struct Pelican
function Pelican_ctor (line 70) | void Pelican_ctor(void) {
function QState (line 77) | static QState Pelican_initial(Pelican * const me) {
function QState (line 82) | static QState Pelican_operational(Pelican * const me) {
function QState (line 116) | static QState Pelican_carsEnabled(Pelican * const me) {
function QState (line 138) | static QState Pelican_carsGreen(Pelican * const me) {
function QState (line 168) | static QState Pelican_carsGreenNoPed(Pelican * const me) {
function QState (line 195) | static QState Pelican_carsGreenInt(Pelican * const me) {
function QState (line 217) | static QState Pelican_carsGreenPedWait(Pelican * const me) {
function QState (line 239) | static QState Pelican_carsYellow(Pelican * const me) {
function QState (line 271) | static QState Pelican_pedsEnabled(Pelican * const me) {
function QState (line 293) | static QState Pelican_pedsWalk(Pelican * const me) {
function QState (line 324) | static QState Pelican_pedsFlash(Pelican * const me) {
function QState (line 372) | static QState Pelican_offline(Pelican * const me) {
FILE: examples/pic24_dspic/pelican_microstick2-pic24/pelican.h
type PelicanSignals (line 22) | enum PelicanSignals {
type Pelican (line 35) | struct Pelican
FILE: examples/pic24_dspic/pelican_microstick2-pic24/qk/xc16/bsp.c
function _T2Interrupt (line 61) | QK_ISR(no_auto_psv) _T2Interrupt() {
function _INT0Interrupt (line 69) | QK_ISR(auto_psv) _INT0Interrupt() {
function BSP_init (line 78) | void BSP_init(void) {
function BSP_terminate (line 86) | void BSP_terminate(int16_t result) {
function BSP_showState (line 90) | void BSP_showState(char_t const *state) {
function BSP_signalCars (line 94) | void BSP_signalCars(enum BSP_CarsSignal sig) {
function BSP_signalPeds (line 115) | void BSP_signalPeds(enum BSP_PedsSignal sig) {
function Q_NORETURN (line 133) | Q_NORETURN Q_onAssert(char const Q_ROM * const file, int line) {
function QF_onStartup (line 142) | void QF_onStartup(void) { /* entered with interrupts locked */
function QF_onCleanup (line 159) | void QF_onCleanup(void) {
function QF_stop (line 162) | void QF_stop(void) {
function QK_onIdle (line 165) | void QK_onIdle(void) {
FILE: examples/pic24_dspic/pelican_microstick2-pic24/qv/xc16/bsp.c
function _T2Interrupt (line 61) | void __attribute__((__interrupt__, auto_psv))
function _INT0Interrupt (line 69) | void __attribute__((__interrupt__, auto_psv))
function BSP_init (line 77) | void BSP_init(void) {
function BSP_terminate (line 85) | void BSP_terminate(int16_t result) {
function BSP_showState (line 89) | void BSP_showState(char_t const *state) {
function BSP_signalCars (line 93) | void BSP_signalCars(enum BSP_CarsSignal sig) {
function BSP_signalPeds (line 114) | void BSP_signalPeds(enum BSP_PedsSignal sig) {
function Q_NORETURN (line 132) | Q_NORETURN Q_onAssert(char const Q_ROM * const file, int line) {
function QF_onStartup (line 141) | void QF_onStartup(void) { /* entered with interrupts locked */
function QF_onCleanup (line 158) | void QF_onCleanup(void) {
function QF_stop (line 161) | void QF_stop(void) {
function QV_onIdle (line 164) | void QV_onIdle(void) { /* entered with interrupts DISABLED, see NOTE01 */
FILE: examples/workstation/blinky/blinky.c
function BSP_init (line 25) | void BSP_init(void) {
function BSP_ledOff (line 31) | void BSP_ledOff(void) { PRINTF_S("%s\n", "LED OFF"); }
function BSP_ledOn (line 32) | void BSP_ledOn(void) { PRINTF_S("%s\n", "LED ON"); }
function QF_onStartup (line 35) | void QF_onStartup(void) {}
function QF_onCleanup (line 36) | void QF_onCleanup(void) {}
function QF_onClockTickISR (line 37) | void QF_onClockTickISR(void) {
function Q_NORETURN (line 40) | Q_NORETURN Q_onAssert(char_t const Q_ROM * const module, int_t loc) {
type Blinky (line 52) | typedef struct Blinky {
function main (line 76) | int main(void) {
function Blinky_ctor (line 93) | static void Blinky_ctor(void) {
function QState (line 101) | static QState Blinky_initial(Blinky * const me) {
function QState (line 113) | static QState Blinky_off(Blinky * const me) {
function QState (line 135) | static QState Blinky_on(Blinky * const me) {
FILE: examples/workstation/calc/bsp.c
function BSP_clear (line 54) | void BSP_clear(void) {
function BSP_insert (line 61) | void BSP_insert(int keyId) {
function BSP_negate (line 73) | void BSP_negate(void) {
function BSP_display (line 78) | void BSP_display(void) {
function BSP_exit (line 82) | void BSP_exit(void) {
function BSP_get_value (line 88) | double BSP_get_value(void) {
function BSP_eval (line 92) | int BSP_eval(double operand1, int oper, double operand2) {
function BSP_message (line 136) | void BSP_message(char const *msg) {
function QF_onStartup (line 141) | void QF_onStartup(void) {
function QF_onCleanup (line 145) | void QF_onCleanup(void) {
function QF_onClockTickISR (line 149) | void QF_onClockTickISR(void) {
function Q_NORETURN (line 154) | Q_NORETURN Q_onAssert(char const * const file, int line) {
FILE: examples/workstation/calc/calc.c
type Calc (line 25) | typedef struct Calc {
function Calc_ctor (line 68) | void Calc_ctor(void) {
function QState (line 76) | static QState Calc_initial(Calc * const me) {
function QState (line 82) | static QState Calc_on(Calc * const me) {
function QState (line 122) | static QState Calc_error(Calc * const me) {
function QState (line 145) | static QState Calc_ready(Calc * const me) {
function QState (line 202) | static QState Calc_result(Calc * const me) {
function QState (line 225) | static QState Calc_begin(Calc * const me) {
function QState (line 260) | static QState Calc_operand1(Calc * const me) {
function QState (line 301) | static QState Calc_zero1(Calc * const me) {
function QState (line 343) | static QState Calc_int1(Calc * const me) {
function QState (line 379) | static QState Calc_frac1(Calc * const me) {
function QState (line 415) | static QState Calc_negated1(Calc * const me) {
function QState (line 470) | static QState Calc_opEntered(Calc * const me) {
function QState (line 526) | static QState Calc_operand2(Calc * const me) {
function QState (line 580) | static QState Calc_zero2(Calc * const me) {
function QState (line 622) | static QState Calc_int2(Calc * const me) {
function QState (line 658) | static QState Calc_frac2(Calc * const me) {
function QState (line 694) | static QState Calc_negated2(Calc * const me) {
function QState (line 749) | static QState Calc_final(Calc * const me) {
FILE: examples/workstation/calc/calc.h
type CalcSignals (line 22) | enum CalcSignals {
FILE: examples/workstation/calc/main.c
function Q_DEFINE_THIS_FILE (line 40) | Q_DEFINE_THIS_FILE
FILE: examples/workstation/comp/alarm.c
function Alarm_ctor (line 46) | void Alarm_ctor(Alarm * const me) {
function QState (line 51) | QState Alarm_initial(Alarm * const me) {
function QState (line 56) | QState Alarm_off(Alarm * const me) {
function QState (line 104) | QState Alarm_on(Alarm * const me) {
FILE: examples/workstation/comp/alarm.h
type Alarm (line 37) | typedef struct AlarmTag {
FILE: examples/workstation/comp/bsp.c
function BSP_init (line 44) | void BSP_init(void) {
function QF_onStartup (line 56) | void QF_onStartup(void) {
function QF_onCleanup (line 61) | void QF_onCleanup(void) {
function QF_onClockTickISR (line 66) | void QF_onClockTickISR(void) {
function Q_NORETURN (line 119) | Q_NORETURN Q_onAssert(char_t const Q_ROM * const file, int_t line) {
FILE: examples/workstation/comp/clock.h
type AlarmClockSignals (line 39) | enum AlarmClockSignals {
type AlarmClockTag (line 51) | struct AlarmClockTag
FILE: examples/workstation/comp/comp.c
type AlarmClockTag (line 43) | struct AlarmClockTag { /* the AlarmClock active object */
function AlarmClock_ctor (line 59) | void AlarmClock_ctor(void) {
function QState (line 65) | QState AlarmClock_initial(AlarmClock * const me) {
function QState (line 72) | QState AlarmClock_final(AlarmClock * const me) {
function QState (line 89) | QState AlarmClock_timekeeping(AlarmClock * const me) {
function QState (line 143) | QState AlarmClock_mode24hr(AlarmClock * const me) {
function QState (line 174) | QState AlarmClock_mode12hr(AlarmClock * const me) {
FILE: examples/workstation/comp/main.c
function main (line 48) | int main (void) {
FILE: examples/workstation/defer/bsp.c
function BSP_init (line 44) | void BSP_init(void) {
function Q_NORETURN (line 47) | Q_NORETURN Q_onAssert(char_t const Q_ROM * const file, int_t line) {
function QF_onStartup (line 53) | void QF_onStartup(void) {
function QF_onCleanup (line 58) | void QF_onCleanup(void) {
function QF_onClockTickISR (line 63) | void QF_onClockTickISR(void) {
FILE: examples/workstation/defer/defer.c
type TServer (line 41) | typedef struct TServerTag { /* Transaction Server active object */
function TServer_ctor (line 64) | void TServer_ctor(void) {
function QState (line 68) | QState TServer_initial(TServer * const me) {
function QState (line 73) | QState TServer_final(TServer * const me) {
function QState (line 89) | QState TServer_operational(TServer * const me) {
function QState (line 113) | QState TServer_idle(TServer * const me) {
function QState (line 135) | QState TServer_receiving(TServer * const me) {
function QState (line 158) | QState TServer_authorizing(TServer * const me) {
function TServer_deferRequest (line 181) | void TServer_deferRequest(TServer * const me) {
function TServer_recallRequest (line 191) | void TServer_recallRequest(TServer * const me) {
FILE: examples/workstation/defer/defer.h
type TServerSignals (line 37) | enum TServerSignals {
type TServerTag (line 42) | struct TServerTag
FILE: examples/workstation/defer/main.c
function main (line 48) | int main (void) {
FILE: examples/workstation/dpp-comp/bsp.c
function BSP_init (line 47) | void BSP_init(void) {
function BSP_terminate (line 58) | void BSP_terminate(int16_t result) {
function BSP_displayPhilStat (line 63) | void BSP_displayPhilStat(uint8_t n, char_t const *stat) {
function BSP_displayPaused (line 67) | void BSP_displayPaused(uint8_t paused) {
function BSP_random (line 71) | uint32_t BSP_random(void) { /* a very cheap pseudo-random-number genera...
function BSP_randomSeed (line 79) | void BSP_randomSeed(uint32_t seed) {
function Q_NORETURN (line 85) | Q_NORETURN Q_onAssert(char_t const Q_ROM * const module, int_t id) {
function QF_onStartup (line 91) | void QF_onStartup(void) {
function QF_onCleanup (line 96) | void QF_onCleanup(void) {
function QF_onClockTickISR (line 101) | void QF_onClockTickISR(void) {
FILE: examples/workstation/dpp-comp/dpp.h
type DPPSignals (line 22) | enum DPPSignals {
type Philo (line 37) | typedef struct Philo {
type Table (line 56) | struct Table
FILE: examples/workstation/dpp-comp/main.c
function int_t (line 48) | int_t main() {
FILE: examples/workstation/dpp-comp/philo.c
function Philo_ctor (line 43) | void Philo_ctor(Philo * const me, uint8_t num) {
function QState (line 49) | QState Philo_initial(Philo * const me) {
function QState (line 55) | QState Philo_thinking(Philo * const me) {
function QState (line 90) | QState Philo_hungry(Philo * const me) {
function QState (line 118) | QState Philo_eating(Philo * const me) {
FILE: examples/workstation/dpp-comp/table.c
type Table (line 28) | typedef struct Table {
type Table (line 54) | struct Table
function Table_ctor (line 65) | void Table_ctor(void) {
function QState (line 80) | static QState Table_initial(Table * const me) {
function QState (line 92) | static QState Table_active(Table * const me) {
function QState (line 133) | static QState Table_serving(Table * const me) {
function QState (line 255) | static QState Table_paused(Table * const me) {
FILE: examples/workstation/dpp/bsp.c
function BSP_init (line 47) | void BSP_init(void) {
function BSP_terminate (line 58) | void BSP_terminate(int16_t result) {
function BSP_displayPhilStat (line 63) | void BSP_displayPhilStat(uint8_t n, char_t const *stat) {
function BSP_displayPaused (line 67) | void BSP_displayPaused(uint8_t paused) {
function BSP_random (line 71) | uint32_t BSP_random(void) { /* a very cheap pseudo-random-number genera...
function BSP_randomSeed (line 79) | void BSP_randomSeed(uint32_t seed) {
function Q_NORETURN (line 85) | Q_NORETURN Q_onAssert(char_t const Q_ROM * const module, int_t id) {
function QF_onStartup (line 91) | void QF_onStartup(void) {
function QF_onCleanup (line 96) | void QF_onCleanup(void) {
function QF_onClockTickISR (line 101) | void QF_onClockTickISR(void) {
FILE: examples/workstation/dpp/dpp.h
type DPPSignals (line 22) | enum DPPSignals {
type Philo (line 37) | struct Philo
type Philo (line 40) | struct Philo
type Philo (line 43) | struct Philo
type Philo (line 46) | struct Philo
type Philo (line 49) | struct Philo
type Table (line 52) | struct Table
FILE: examples/workstation/dpp/main.c
function int_t (line 54) | int_t main() {
FILE: examples/workstation/dpp/philo.c
type Philo (line 28) | typedef struct Philo {
type Philo (line 49) | struct Philo
type Philo (line 53) | struct Philo
type Philo (line 57) | struct Philo
type Philo (line 61) | struct Philo
type Philo (line 65) | struct Philo
function Philo_ctor (line 77) | void Philo_ctor(void) {
function QState (line 89) | static QState Philo_initial(Philo * const me) {
function QState (line 94) | static QState Philo_thinking(Philo * const me) {
function QState (line 129) | static QState Philo_hungry(Philo * const me) {
function QState (line 157) | static QState Philo_eating(Philo * const me) {
FILE: examples/workstation/dpp/table.c
type Table (line 28) | typedef struct Table {
type Table (line 53) | struct Table
function Table_ctor (line 64) | void Table_ctor(void) {
function QState (line 78) | static QState Table_initial(Table * const me) {
function QState (line 89) | static QState Table_active(Table * const me) {
function QState (line 112) | static QState Table_serving(Table * const me) {
function QState (line 221) | static QState Table_paused(Table * const me) {
FILE: examples/workstation/history/bsp.c
function BSP_init (line 48) | void BSP_init(void) {
function BSP_exit (line 59) | void BSP_exit(void) {
function QF_onStartup (line 66) | void QF_onStartup(void) {
function QF_onCleanup (line 71) | void QF_onCleanup(void) {
function QF_onClockTickISR (line 75) | void QF_onClockTickISR(void) {
function Q_NORETURN (line 80) | Q_NORETURN Q_onAssert(char const * const file, int line) {
FILE: examples/workstation/history/history.c
type ToastOven (line 30) | typedef struct ToastOven {
function ToastOven_ctor (line 62) | void ToastOven_ctor(void) {
function QState (line 70) | static QState ToastOven_initial(ToastOven * const me) {
function QState (line 78) | static QState ToastOven_doorClosed(ToastOven * const me) {
function QState (line 132) | static QState ToastOven_heating(ToastOven * const me) {
function QState (line 160) | static QState ToastOven_toasting(ToastOven * const me) {
function QState (line 177) | static QState ToastOven_baking(ToastOven * const me) {
function QState (line 194) | static QState ToastOven_off(ToastOven * const me) {
function QState (line 211) | static QState ToastOven_doorOpen(ToastOven * const me) {
function QState (line 244) | static QState ToastOven_final(ToastOven * const me) {
FILE: examples/workstation/history/history.h
type ToastOvenSignals (line 22) | enum ToastOvenSignals {
FILE: examples/workstation/history/main.c
function Q_DEFINE_THIS_FILE (line 41) | Q_DEFINE_THIS_FILE
FILE: examples/workstation/pelican/bsp.c
function BSP_init (line 44) | void BSP_init(void) {
function BSP_terminate (line 54) | void BSP_terminate(int16_t result) {
function BSP_showState (line 59) | void BSP_showState(char_t const *state) {
function BSP_signalCars (line 63) | void BSP_signalCars(enum BSP_CarsSignal sig) {
function BSP_signalPeds (line 84) | void BSP_signalPeds(enum BSP_PedsSignal sig) {
function QF_onStartup (line 102) | void QF_onStartup(void) {
function QF_onCleanup (line 107) | void QF_onCleanup(void) {
function QF_onClockTickISR (line 112) | void QF_onClockTickISR(void) {
function Q_NORETURN (line 140) | Q_NORETURN Q_onAssert(char const * const module, int location) {
FILE: examples/workstation/pelican/bsp.h
type BSP_CarsSignal (line 39) | enum BSP_CarsSignal {
type BSP_PedsSignal (line 43) | enum BSP_PedsSignal {
type BSP_CarsSignal (line 49) | enum BSP_CarsSignal
type BSP_PedsSignal (line 50) | enum BSP_PedsSignal
FILE: examples/workstation/pelican/main.c
function main (line 48) | int main (void) {
FILE: examples/workstation/pelican/pelican.c
type Pelican (line 35) | typedef struct Pelican {
type Pelican (line 59) | struct Pelican
function Pelican_ctor (line 70) | void Pelican_ctor(void) {
function QState (line 77) | static QState Pelican_initial(Pelican * const me) {
function QState (line 82) | static QState Pelican_operational(Pelican * const me) {
function QState (line 116) | static QState Pelican_carsEnabled(Pelican * const me) {
function QState (line 138) | static QState Pelican_carsGreen(Pelican * const me) {
function QState (line 168) | static QState Pelican_carsGreenNoPed(Pelican * const me) {
function QState (line 195) | static QState Pelican_carsGreenInt(Pelican * const me) {
function QState (line 217) | static QState Pelican_carsGreenPedWait(Pelican * const me) {
function QState (line 239) | static QState Pelican_carsYellow(Pelican * const me) {
function QState (line 271) | static QState Pelican_pedsEnabled(Pelican * const me) {
function QState (line 293) | static QState Pelican_pedsWalk(Pelican * const me) {
function QState (line 324) | static QState Pelican_pedsFlash(Pelican * const me) {
function QState (line 372) | static QState Pelican_offline(Pelican * const me) {
FILE: examples/workstation/pelican/pelican.h
type PelicanSignals (line 22) | enum PelicanSignals {
type Pelican (line 35) | struct Pelican
FILE: examples/workstation/qhsmtst/bsp.c
function BSP_init (line 52) | void BSP_init(char const *fname) {
function BSP_exit (line 75) | void BSP_exit(void) {
function BSP_display (line 82) | void BSP_display(char const *msg) {
function BSP_dispatch (line 86) | void BSP_dispatch(QSignal sig) {
function QF_onStartup (line 97) | void QF_onStartup(void) {
function QF_onCleanup (line 101) | void QF_onCleanup(void) {
function QF_onClockTickISR (line 105) | void QF_onClockTickISR(void) {
function Q_NORETURN (line 110) | Q_NORETURN Q_onAssert(char const * const file, int line) {
FILE: examples/workstation/qhsmtst/main.c
function main (line 44) | int main(int argc, char *argv[]) {
FILE: examples/workstation/qhsmtst/qhsmtst.c
type QHsmTst (line 25) | typedef struct QHsmTst {
function QHsmTst_ctor (line 59) | void QHsmTst_ctor(void) {
function QState (line 67) | static QState QHsmTst_initial(QHsmTst * const me) {
function QState (line 77) | static QState QHsmTst_s(QHsmTst * const me) {
function QState (line 131) | static QState QHsmTst_s1(QHsmTst * const me) {
function QState (line 205) | static QState QHsmTst_s11(QHsmTst * const me) {
function QState (line 253) | static QState QHsmTst_s2(QHsmTst * const me) {
function QState (line 307) | static QState QHsmTst_s21(QHsmTst * const me) {
function QState (line 354) | static QState QHsmTst_s211(QHsmTst * const me) {
FILE: examples/workstation/qhsmtst/qhsmtst.h
type QHsmTstSignals (line 22) | enum QHsmTstSignals {
FILE: examples/workstation/reminder/bsp.c
function BSP_init (line 44) | void BSP_init(void) {
function Q_NORETURN (line 47) | Q_NORETURN Q_onAssert(char_t const Q_ROM * const file, int_t line) {
function QF_onStartup (line 53) | void QF_onStartup(void) {
function QF_onCleanup (line 58) | void QF_onCleanup(void) {
function QF_onClockTickISR (line 63) | void QF_onClockTickISR(void) {
FILE: examples/workstation/reminder/main.c
function main (line 50) | int main (void) {
FILE: examples/workstation/reminder/reminder.c
type Sensor (line 41) | typedef struct SensorTag {
function Sensor_ctor (line 60) | void Sensor_ctor(void) {
function QState (line 65) | QState Sensor_initial(Sensor * const me) {
function QState (line 71) | QState Sensor_final(Sensor * const me) {
function QState (line 87) | QState Sensor_polling(Sensor * const me) {
function QState (line 128) | QState Sensor_processing(Sensor * const me) {
function QState (line 143) | QState Sensor_idle(Sensor * const me) {
function QState (line 163) | QState Sensor_busy(Sensor * const me) {
FILE: examples/workstation/reminder/reminder.h
type SensorSignals (line 37) | enum SensorSignals {
type SensorTag (line 43) | struct SensorTag
FILE: examples/workstation/reminder2/bsp.c
function BSP_init (line 44) | void BSP_init(void) {
function BSP_echo (line 52) | void BSP_echo(double sum) {
function BSP_result (line 57) | void BSP_result(double sum) {
function QF_onStartup (line 63) | void QF_onStartup(void) {
function QF_onCleanup (line 68) | void QF_onCleanup(void) {
function QF_onClockTickISR (line 73) | void QF_onClockTickISR(void) {
function Q_NORETURN (line 89) | Q_NORETURN Q_onAssert(char_t const Q_ROM * const file, int_t line) {
FILE: examples/workstation/reminder2/main.c
function main (line 48) | int main (void) {
FILE: examples/workstation/reminder2/reminder2.c
type Cruncher (line 39) | typedef struct CruncherTag { /* the Cruncher active object */
function Cruncher_ctor (line 53) | void Cruncher_ctor(void) {
function QState (line 57) | QState Cruncher_initial(Cruncher * const me) {
function QState (line 61) | QState Cruncher_processing(Cruncher * const me) {
function QState (line 109) | QState Cruncher_final(Cruncher * const me) {
FILE: examples/workstation/reminder2/reminder2.h
type ReminderSignals (line 38) | enum ReminderSignals {
type CruncherTag (line 45) | struct CruncherTag
FILE: include/qassert.h
type char_t (line 77) | typedef char char_t;
type int_t (line 86) | typedef int int_t;
FILE: include/qepn.h
type char_t (line 70) | typedef char char_t;
type int_t (line 73) | typedef int int_t;
type enum_t (line 76) | typedef int enum_t;
type float32_t (line 83) | typedef float float32_t;
type float64_t (line 90) | typedef double float64_t;
type QSignal (line 93) | typedef uint8_t QSignal;
type QParam (line 101) | typedef uint8_t QParam;
type QParam (line 103) | typedef uint16_t QParam;
type QParam (line 116) | typedef uint32_t QParam;
type QParam (line 118) | typedef uint64_t QParam;
type QEvt (line 131) | typedef struct {
type uint_fast8_t (line 155) | typedef uint_fast8_t QState;
type QState (line 158) | typedef QState (*QStateHandler)(void * const me);
type QHsmVtable (line 162) | typedef struct QHsmVtable QHsmVtable;
type QHsm (line 183) | typedef struct {
type QHsmVtable (line 191) | struct QHsmVtable {
FILE: include/qfn.h
type QTimeEvtCtr (line 60) | typedef uint8_t QTimeEvtCtr;
type QTimeEvtCtr (line 75) | typedef uint16_t QTimeEvtCtr;
type QTimeEvtCtr (line 77) | typedef uint32_t QTimeEvtCtr;
type QTimer (line 84) | typedef struct {
type QActive (line 122) | typedef struct QActive {
type QActiveVtable (line 149) | typedef struct {
type QActiveCB (line 397) | typedef struct {
FILE: include/qkn.h
type QK_PrivAttr (line 45) | typedef struct {
type uint_fast16_t (line 126) | typedef uint_fast16_t QSchedStatus;
FILE: include/qpn.h
type QActiveCB (line 84) | typedef QActiveCB QMActiveCB;
type QActive (line 87) | typedef QActive QMActive;
type QHsm (line 90) | typedef QHsm QMsm;
FILE: ports/arm-cm/qk/arm/qfn_port.h
function QF_set_BASEPRI (line 75) | static __inline void QF_set_BASEPRI(unsigned basePri) {
FILE: ports/arm-cm/qk/arm/qkn_port.c
function QK_init (line 68) | void QK_init(void) {
function PendSV_Handler (line 121) | void PendSV_Handler(void) {
FILE: ports/arm-cm/qk/armclang/qkn_port.c
function QK_init (line 72) | void QK_init(void) {
function PendSV_Handler (line 125) | __attribute__ ((naked))
function Thread_ret (line 183) | __attribute__ ((naked))
function NMI_Handler (line 225) | __attribute__ ((naked))
FILE: ports/arm-cm/qk/gnu/qkn_port.c
function QK_init (line 72) | void QK_init(void) {
function PendSV_Handler (line 130) | __attribute__ ((naked, optimize("-fno-stack-protector")))
function Thread_ret (line 188) | __attribute__ ((naked, optimize("-fno-stack-protector")))
function NMI_Handler (line 230) | __attribute__ ((naked, optimize("-fno-stack-protector")))
FILE: ports/arm-cm/qk/iar/qkn_port.c
function QK_init (line 71) | void QK_init(void) {
function __stackless (line 124) | __stackless
function __stackless (line 182) | __stackless
function __stackless (line 224) | __stackless
FILE: ports/arm-cm/qv/arm/qfn_port.h
function QF_set_BASEPRI (line 89) | static __inline void QF_set_BASEPRI(unsigned basePri) {
FILE: ports/arm-cm/qv/arm/qvn_port.c
function QV_init (line 64) | void QV_init(void) {
FILE: ports/arm-cm/qv/armclang/qvn_port.c
function QV_init (line 64) | void QV_init(void) {
FILE: ports/arm-cm/qv/gnu/qvn_port.c
function QV_init (line 64) | void QV_init(void) {
FILE: ports/arm-cm/qv/iar/qvn_port.c
function QV_init (line 64) | void QV_init(void) {
FILE: ports/lint-plus/16bit/stdint.h
type int_fast8_t (line 35) | typedef signed int int_fast8_t;
type uint_fast8_t (line 36) | typedef unsigned int uint_fast8_t;
type int_fast16_t (line 37) | typedef signed int int_fast16_t;
type uint_fast16_t (line 38) | typedef unsigned int uint_fast16_t;
type int_fast32_t (line 39) | typedef signed long int_fast32_t;
type uint_fast32_t (line 40) | typedef unsigned long uint_fast32_t;
FILE: ports/lint-plus/32bit/stdint.h
type int_fast8_t (line 35) | typedef signed int int_fast8_t;
type uint_fast8_t (line 36) | typedef unsigned int uint_fast8_t;
type int_fast16_t (line 37) | typedef signed int int_fast16_t;
type uint_fast16_t (line 38) | typedef unsigned int uint_fast16_t;
type int_fast32_t (line 39) | typedef signed long int_fast32_t;
type uint_fast32_t (line 40) | typedef unsigned long uint_fast32_t;
FILE: ports/lint-plus/stdbool.h
type _Bool (line 19) | typedef _Bool bool;
FILE: ports/posix-qv/qfn_posix.c
type termios (line 80) | struct termios
type timespec (line 82) | struct timespec
function QActive_ctor (line 95) | void QActive_ctor(QActive * const me, QStateHandler initial) {
function QActive_postX_ (line 111) | bool QActive_postX_(QActive * const me, uint_fast8_t margin,
function QActive_postXISR_ (line 163) | bool QActive_postXISR_(QActive * const me, uint_fast8_t margin,
function QF_tickXISR (line 210) | void QF_tickXISR(uint_fast8_t const tickRate) {
function QActive_armX (line 247) | void QActive_armX(QActive * const me, uint_fast8_t const tickRate,
function QActive_disarmX (line 265) | void QActive_disarmX(QActive * const me, uint_fast8_t const tickRate) {
function QF_enterCriticalSection_ (line 281) | void QF_enterCriticalSection_(void) {
function QF_leaveCriticalSection_ (line 285) | void QF_leaveCriticalSection_(void) {
function QF_init (line 301) | void QF_init(uint_fast8_t maxActive) {
function int_t (line 367) | int_t QF_run(void) {
function QF_stop (line 468) | void QF_stop(void) {
function QF_setTickRate (line 477) | void QF_setTickRate(uint32_t ticksPerSec, int_t tickPrio) {
function QF_consoleSetup (line 487) | void QF_consoleSetup(void) {
function QF_consoleCleanup (line 496) | void QF_consoleCleanup(void) {
function QF_consoleGetKey (line 500) | int QF_consoleGetKey(void) {
function QF_consoleWaitForKey (line 511) | int QF_consoleWaitForKey(void) {
function sigIntHandler (line 531) | static void sigIntHandler(int dummy) {
FILE: ports/win32-qv/qfn_win32.c
function QActive_ctor (line 83) | void QActive_ctor(QActive * const me, QStateHandler initial) {
function QActive_postX_ (line 99) | bool QActive_postX_(QActive * const me, uint_fast8_t margin,
function QActive_postXISR_ (line 151) | bool QActive_postXISR_(QActive * const me, uint_fast8_t margin,
function QF_tickXISR (line 198) | void QF_tickXISR(uint_fast8_t const tickRate) {
function QActive_armX (line 235) | void QActive_armX(QActive * const me, uint_fast8_t const tickRate,
function QActive_disarmX (line 253) | void QActive_disarmX(QActive * const me, uint_fast8_t const tickRate) {
function QF_enterCriticalSection_ (line 269) | void QF_enterCriticalSection_(void) {
function QF_leaveCriticalSection_ (line 273) | void QF_leaveCriticalSection_(void) {
function QF_init (line 289) | void QF_init(uint_fast8_t maxActive) {
function int_t (line 342) | int_t QF_run(void) {
function QF_stop (line 432) | void QF_stop(void) {
function QF_setTickRate (line 437) | void QF_setTickRate(uint32_t ticksPerSec, int_t tickPrio) {
function QF_consoleSetup (line 448) | void QF_consoleSetup(void) {
function QF_consoleCleanup (line 451) | void QF_consoleCleanup(void) {
function QF_consoleGetKey (line 454) | int QF_consoleGetKey(void) {
function QF_consoleWaitForKey (line 461) | int QF_consoleWaitForKey(void) {
function DWORD (line 466) | static DWORD WINAPI ticker_thread(LPVOID arg) { /* for CreateThread() */
FILE: ports/win32-qv/qwin_gui.c
function HWND (line 46) | HWND CreateCustDialog(HINSTANCE hInst, int iDlg, HWND hParent,
function OwnerDrawnButton_init (line 80) | void OwnerDrawnButton_init(OwnerDrawnButton * const me,
function OwnerDrawnButton_xtor (line 92) | void OwnerDrawnButton_xtor(OwnerDrawnButton * const me) {
function OwnerDrawnButton_draw (line 98) | enum OwnerDrawnButtonAction OwnerDrawnButton_draw(
function OwnerDrawnButton_set (line 133) | void OwnerDrawnButton_set(OwnerDrawnButton * const me, int isDepressed) {
function BOOL (line 146) | BOOL OwnerDrawnButton_isDepressed(OwnerDrawnButton const * const me) {
function GraphicDisplay_init (line 151) | void GraphicDisplay_init(GraphicDisplay * const me,
function GraphicDisplay_xtor (line 187) | void GraphicDisplay_xtor(GraphicDisplay * const me) {
function GraphicDisplay_clear (line 193) | void GraphicDisplay_clear(GraphicDisplay * const me) {
function GraphicDisplay_redraw (line 207) | void GraphicDisplay_redraw(GraphicDisplay * const me) {
function SegmentDisplay_init (line 213) | void SegmentDisplay_init(SegmentDisplay * const me,
function SegmentDisplay_xtor (line 230) | void SegmentDisplay_xtor(SegmentDisplay * const me) {
function BOOL (line 244) | BOOL SegmentDisplay_initSegment(SegmentDisplay * const me,
function BOOL (line 256) | BOOL SegmentDisplay_initBitmap(SegmentDisplay * const me,
function BOOL (line 268) | BOOL SegmentDisplay_setSegment(SegmentDisplay * const me,
function DrawBitmap (line 286) | void DrawBitmap(HDC hdc, HBITMAP hBitmap,
FILE: ports/win32-qv/qwin_gui.h
type OwnerDrawnButton (line 58) | typedef struct {
type OwnerDrawnButtonAction (line 66) | enum OwnerDrawnButtonAction {
type OwnerDrawnButtonAction (line 78) | enum OwnerDrawnButtonAction
type GraphicDisplay (line 88) | typedef struct {
type SegmentDisplay (line 124) | typedef struct {
FILE: src/qfn/qepn.c
function QHsm_ctor (line 84) | void QHsm_ctor(QHsm * const me, QStateHandler initial) {
function QHsm_init_ (line 105) | void QHsm_init_(QHsm * const me) {
function QState (line 172) | QState QHsm_top(void const * const me) {
function QHsm_dispatch_ (line 190) | void QHsm_dispatch_(QHsm * const me) {
function int_fast8_t (line 292) | static int_fast8_t QHsm_tran_(QHsm * const me,
function QStateHandler (line 450) | QStateHandler QHsm_childState_(QHsm * const me,
FILE: src/qfn/qfn.c
function QActive_ctor (line 99) | void QActive_ctor(QActive * const me, QStateHandler initial) {
function QActive_postX_ (line 146) | bool QActive_postX_(QActive * const me, uint_fast8_t margin,
function QActive_postXISR_ (line 232) | bool QActive_postXISR_(QActive * const me, uint_fast8_t margin,
function QF_init (line 315) | void QF_init(uint_fast8_t maxActive) {
function QF_tickXISR (line 398) | void QF_tickXISR(uint_fast8_t const tickRate) {
function QActive_armX (line 465) | void QActive_armX(QActive * const me, uint_fast8_t const tickRate,
function QActive_disarmX (line 495) | void QActive_disarmX(QActive * const me, uint_fast8_t const tickRate) {
FILE: src/qkn/qkn.c
function initialize (line 69) | static void initialize(void) {
function int_t (line 121) | int_t QF_run(void) {
function QSchedStatus (line 161) | QSchedStatus QK_schedLock(uint_fast8_t ceiling) {
function QK_schedUnlock (line 200) | void QK_schedUnlock(QSchedStatus stat) {
function uint_fast8_t (line 247) | uint_fast8_t QK_sched_(void) {
function QK_activate_ (line 291) | void QK_activate_(void) {
FILE: src/qvn/qvn.c
function int_t (line 64) | int_t QF_run(void) {
Condensed preview — 828 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (9,720K chars).
[
{
"path": ".gitignore",
"chars": 390,
"preview": "*.obj\n*.o\n*.d\n*.lib\n*.a\n*.elf\n*.err\n*.hex\n*.exe\n*.EXE\n*.map\n*.dep\n*.pdf\n*.PDF\n*.Hbp\n*.nav\n*.tps\n*.tws\n*.tmp\n*.log\n*.chm\n"
},
{
"path": ".gitmodules",
"chars": 99,
"preview": "[submodule \"3rd_party\"]\n\tpath = 3rd_party\n\turl = https://github.com/QuantumLeaps/3rd_party-qpn.git\n"
},
{
"path": "GPLv3.txt",
"chars": 35147,
"preview": " GNU GENERAL PUBLIC LICENSE\n Version 3, 29 June 2007\n\n Copyright (C) 2007 Free "
},
{
"path": "LICENSE.txt",
"chars": 599,
"preview": "The QP-nano Real-Time Embedded Framework (RTEF) is licensed under the\ndual-licensing model, in which both the open sourc"
},
{
"path": "README.md",
"chars": 6402,
"preview": "\n\n------------------------------------------------"
},
{
"path": "doxygen/Doxyfile",
"chars": 9981,
"preview": "# Doxyfile 1.9.4\n\n@INCLUDE = ../../ql-doxygen/ql-doxyfile\n\n#------------------------------------------------------------"
},
{
"path": "doxygen/Doxyfile-CHM",
"chars": 539,
"preview": "# Doxyfile 1.9.2\n\n@INCLUDE = Doxyfile\n\n#---------------------------------------------------------------------------\n# Co"
},
{
"path": "doxygen/api.dox",
"chars": 4325,
"preview": "/*! @page api API Reference\n\n@tableofcontents\n\n@section api_qepn QEP-nano (Hierarchical State Machines)\nQEP is a univers"
},
{
"path": "doxygen/exa.dox",
"chars": 23674,
"preview": "/*! @page exa Examples\n\n@tableofcontents\n\n@section exa_gen General Comments\nThe QP-nano distribution contains many @subp"
},
{
"path": "doxygen/exa_apps.dox",
"chars": 5004,
"preview": "/*##########################################################################*/\n/*! @page exa_apps Example Applications\n\n"
},
{
"path": "doxygen/exa_native.dox",
"chars": 22383,
"preview": "/*##########################################################################*/\n/*! @page exa_native Native Examples (Bui"
},
{
"path": "doxygen/exa_os.dox",
"chars": 1647,
"preview": "/*##########################################################################*/\n/*! @page exa_os Examples for Workstation"
},
{
"path": "doxygen/gs.dox",
"chars": 3018,
"preview": "/*! @page gs Getting Started\n\n@section gs_obtain Downloading & Installing QP-nano™\n@tableofcontents\n\n<p>The mo"
},
{
"path": "doxygen/history.dox",
"chars": 85185,
"preview": "/**\n@page history Revision History\n\n@section qpn_6_9_0 Version 6.9.0, 2020-08-21\n\n- Applied the Doxygen commands `extend"
},
{
"path": "doxygen/img/img.htm",
"chars": 1335,
"preview": "<!-- HTML header for doxygen 1.8.5-->\n<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/"
},
{
"path": "doxygen/lint.dox",
"chars": 539,
"preview": "/*! @page lint PC-Lint\nThe QP-nano framework comes with extensive support for automatic rule checking by means of <a cla"
},
{
"path": "doxygen/macros.h",
"chars": 1065,
"preview": "/*!\n* @file\n* @ingroup qepn qfn qkn qvn\n* macros for porting QP-nano, and command-line macros\n*/\n\n/*! The preprocessor s"
},
{
"path": "doxygen/main.dox",
"chars": 12307,
"preview": "/*! @mainpage About QP-nano™\n\n@image html qpn_banner.jpg\n\n@section ab_new What's new?\nTo check what's new in QP-na"
},
{
"path": "doxygen/make.bat",
"chars": 2565,
"preview": "@echo off\n:: ==========================================================================\n:: Product: batch script for gen"
},
{
"path": "doxygen/modules.dox",
"chars": 2425,
"preview": "/*! @defgroup qepn QEP-nano\n\n@brief\nHierarchical Event Processor\n\nQEP-nano is a universal, UML-compliant event processor"
},
{
"path": "doxygen/ports.dox",
"chars": 4505,
"preview": "/*! @page ports Ports\n\n@section ports_gen General Comments\nThe QP-nano framework can be easily adapted to various operat"
},
{
"path": "doxygen/ports_arm-cm.dox",
"chars": 86351,
"preview": "/*##########################################################################*/\n/*! @page arm-cm ARM Cortex-M\n\n@tableofco"
},
{
"path": "doxygen/ports_native.dox",
"chars": 11732,
"preview": "/*##########################################################################*/\n/*! @page ports_native Native (Bare-Metal"
},
{
"path": "doxygen/ports_os.dox",
"chars": 607,
"preview": "/*##########################################################################*/\n/*! @page ports_os Ports to Third-Party O"
},
{
"path": "doxygen/preview.js",
"chars": 1093,
"preview": "/* Image preview script \n * powered by jQuery (http://www.jquery.com)\n * written by Alen Grakalic (http://cssglobe.com)\n"
},
{
"path": "doxygen/rsm.bat",
"chars": 1939,
"preview": "@echo off\n:: ==========================================================================\n:: Product: QP-nano script for"
},
{
"path": "doxygen/rsm_qpn.cfg",
"chars": 24924,
"preview": "# ==========================================================================\n# Product: Configuration file for MSquared "
},
{
"path": "doxygen/snippets/qepn_qhist.c",
"chars": 902,
"preview": "typedef struct {\n QHsm super; /* inherit QHsm */\n\n QStateHandler hist_doorClosed; /* history of doorClosed */\n} T"
},
{
"path": "doxygen/snippets/qepn_qhsm.c",
"chars": 175,
"preview": "typedef struct {\n QHsm super; /* inherits QHsm */\n\n double operand1;\n double operand2;\n char display[DISP_W"
},
{
"path": "doxygen/snippets/qepn_qhsm_ctor.c",
"chars": 95,
"preview": "void Alarm_ctor(Alarm * const me) {\n QHsm_ctor(&me->super, Q_STATE_CAST(&Alarm_initial));\n}\n"
},
{
"path": "doxygen/snippets/qepn_qhsm_use.c",
"chars": 592,
"preview": "#include \"qpn.h\" /* QP-nano */\n#include \"calc.h\" /* Application interface */\n\nQ_DEFINE_THIS_FILE\n\nstatic Calc l_calc;"
},
{
"path": "doxygen/snippets/qepn_qinit.c",
"chars": 1164,
"preview": "/*..........................................................................*/\nvoid Pelican_ctor(Pelican * const me) {\n "
},
{
"path": "doxygen/snippets/qepn_qtran.c",
"chars": 1258,
"preview": "/* HSM definition ----------------------------------------------------------*/\nQState Pelican_carsGreenNoPed(Pelican * c"
},
{
"path": "doxygen/snippets/qfn_armx.c",
"chars": 1573,
"preview": "/* when #QF_TIMEEVT_PERIODIC is NOT defined... */\nQState Pelican_carsGreen(Pelican * const me) {\n QState status_;\n "
},
{
"path": "doxygen/snippets/qfn_main.c",
"chars": 1017,
"preview": "#include \"qpn.h\" /* QP-nano API */\n#include \"bsp.h\" /* Board Support Package (BSP) */\n#include \"pelican.h\" /* Ap"
},
{
"path": "doxygen/snippets/qfn_post.c",
"chars": 1108,
"preview": "/* event posting from the interrupt context (QACTIVE_POST_ISR()) ... */\n#pragma vector=TIMER0_A0_VECTOR\n__interrupt void"
},
{
"path": "doxygen/snippets/qfn_postx.c",
"chars": 1036,
"preview": "/* \"extended\" event posting from the interrupt context (QACTIVE_POST_X_ISR) */\nvoid SysTick_Handler(void) {\n . . .\n "
},
{
"path": "doxygen/snippets/qfn_qactive.c",
"chars": 425,
"preview": "/* PEdestrian Light CONtrolled (PELICAN) crossing active object */\ntypedef struct {\n QActive super; /* inherits"
},
{
"path": "doxygen/snippets/qfn_tickx.c",
"chars": 600,
"preview": "/* system clock tick ISR for MSP430 from TI (cooperative QV-nano kernel) */\n#pragma vector = TIMERA0_VECTOR\n__interrupt "
},
{
"path": "doxygen/snippets/qkn_lock.c",
"chars": 523,
"preview": "uint32_t BSP_random(void) { /* a very cheap pseudo-random-number generator */\n uint32_t rnd;\n QSchedStatus lockSta"
},
{
"path": "doxygen/snippets/qkn_oncontextsw.c",
"chars": 290,
"preview": "#ifdef QK_ON_CONTEXT_SW\n/* NOTE: the context-switch callback is called with interrupts DISABLED */\nvoid QK_onContextSw(u"
},
{
"path": "doxygen/struct.dox",
"chars": 11317,
"preview": "/*! @page struct Structure and Features\n\n@tableofcontents\n\n@section files Directories and Files\n\nThe following annotated"
},
{
"path": "examples/README.url",
"chars": 111,
"preview": "[InternetShortcut]\nURL=http://www.state-machine.com/qpn/exa.html\nIconFile=http://www.state-machine.com/qp.ico\n\n"
},
{
"path": "examples/arm-cm/README.url",
"chars": 116,
"preview": "[InternetShortcut]\nURL=http://www.state-machine.com/qpn/exa_arm-cm.html\nIconFile=http://www.state-machine.com/qp.ico"
},
{
"path": "examples/arm-cm/blinky_efm32-slstk3401a/README.txt",
"chars": 1406,
"preview": "About this Example\n==================\nThis directory contains a QP example application for the\nEFM32-SLSTK3401A board (P"
},
{
"path": "examples/arm-cm/blinky_efm32-slstk3401a/README.url",
"chars": 134,
"preview": "[InternetShortcut]\nURL=http://www.state-machine.com/qpn/arm-cm_blinky_ek-tm4c123gxl.html\nIconFile=http://www.state-machi"
},
{
"path": "examples/arm-cm/blinky_efm32-slstk3401a/blinky.c",
"chars": 3519,
"preview": "/*****************************************************************************\n* Product: Simple Blinky example\n* Last u"
},
{
"path": "examples/arm-cm/blinky_efm32-slstk3401a/blinky.h",
"chars": 1765,
"preview": "/*****************************************************************************\n* Product: simple \"Blinky\" example\n* Last"
},
{
"path": "examples/arm-cm/blinky_efm32-slstk3401a/bsp.h",
"chars": 1618,
"preview": "/*****************************************************************************\n* Product: Simple Blinky example\n* Last u"
},
{
"path": "examples/arm-cm/blinky_efm32-slstk3401a/main.c",
"chars": 2371,
"preview": "/*****************************************************************************\n* Product: \"Blinky\" example\n* Last Update"
},
{
"path": "examples/arm-cm/blinky_efm32-slstk3401a/qk/armclang/README.txt",
"chars": 1881,
"preview": "About this Example\n==================\nThis example demonstrates how to use the uVision IDE together with\nthe MDK-ARM too"
},
{
"path": "examples/arm-cm/blinky_efm32-slstk3401a/qk/armclang/blinky-qk.uvoptx",
"chars": 20116,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\" ?>\n<ProjectOpt xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance"
},
{
"path": "examples/arm-cm/blinky_efm32-slstk3401a/qk/armclang/blinky-qk.uvprojx",
"chars": 35714,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\" ?>\n<Project xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" x"
},
{
"path": "examples/arm-cm/blinky_efm32-slstk3401a/qk/bsp.c",
"chars": 8719,
"preview": "/*****************************************************************************\n* Product: \"Blinky\" on EFM32-SLSTK3401A b"
},
{
"path": "examples/arm-cm/blinky_efm32-slstk3401a/qk/gnu/Makefile",
"chars": 7932,
"preview": "##############################################################################\n# Product: Makefile for QP-nano on EMF32-"
},
{
"path": "examples/arm-cm/blinky_efm32-slstk3401a/qk/gnu/README.txt",
"chars": 2238,
"preview": "About this Example\n==================\nThis example can be built from the command prompt with the provided\nMakefile. The "
},
{
"path": "examples/arm-cm/blinky_efm32-slstk3401a/qk/gnu/blinky-qk.ld",
"chars": 4333,
"preview": "/*****************************************************************************\n* Product: Linker script for EFM32-SLSTK3"
},
{
"path": "examples/arm-cm/blinky_efm32-slstk3401a/qk/gnu/flash.bat",
"chars": 1249,
"preview": "::============================================================================\n:: Batch file to program the flash of EFM"
},
{
"path": "examples/arm-cm/blinky_efm32-slstk3401a/qk/iar/README.txt",
"chars": 1848,
"preview": "About this Example\n==================\nThis example demonstrates how to use the IAR EWARM IDE to build\na QP application.\n"
},
{
"path": "examples/arm-cm/blinky_efm32-slstk3401a/qk/iar/blinky-qk.ewd",
"chars": 98423,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<project>\n <fileVersion>3</fileVersion>\n <configuration>\n <name>Debu"
},
{
"path": "examples/arm-cm/blinky_efm32-slstk3401a/qk/iar/blinky-qk.ewp",
"chars": 74143,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<project>\n <fileVersion>3</fileVersion>\n <configuration>\n <name>Debu"
},
{
"path": "examples/arm-cm/blinky_efm32-slstk3401a/qk/iar/blinky-qk.eww",
"chars": 153,
"preview": "<?xml version=\"1.0\" encoding=\"iso-8859-1\"?>\n\n<workspace>\n <project>\n <path>$WS_DIR$\\blinky-qk.ewp</path>\n </project"
},
{
"path": "examples/arm-cm/blinky_efm32-slstk3401a/qk/iar/blinky-qk.icf",
"chars": 1313,
"preview": "/*###ICF### Section handled by ICF editor, don't touch! ****/\n/*-Editor annotation file-*/\n/* IcfEditorFile=\"$TOOLKIT_DI"
},
{
"path": "examples/arm-cm/blinky_efm32-slstk3401a/qpn_conf.h",
"chars": 1702,
"preview": "/*****************************************************************************\n* Product: QP-nano configuration for the "
},
{
"path": "examples/arm-cm/blinky_efm32-slstk3401a/qv/armclang/README.txt",
"chars": 1881,
"preview": "About this Example\n==================\nThis example demonstrates how to use the uVision IDE together with\nthe MDK-ARM too"
},
{
"path": "examples/arm-cm/blinky_efm32-slstk3401a/qv/armclang/blinky-qv.uvoptx",
"chars": 20116,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\" ?>\n<ProjectOpt xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance"
},
{
"path": "examples/arm-cm/blinky_efm32-slstk3401a/qv/armclang/blinky-qv.uvprojx",
"chars": 35714,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\" ?>\n<Project xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" x"
},
{
"path": "examples/arm-cm/blinky_efm32-slstk3401a/qv/bsp.c",
"chars": 8584,
"preview": "/*****************************************************************************\n* Product: \"Blinky\" on EFM32-SLSTK3401A b"
},
{
"path": "examples/arm-cm/blinky_efm32-slstk3401a/qv/gnu/Makefile",
"chars": 7934,
"preview": "##############################################################################\n# Product: Makefile for QP-nano on EMF32-"
},
{
"path": "examples/arm-cm/blinky_efm32-slstk3401a/qv/gnu/README.txt",
"chars": 2238,
"preview": "About this Example\n==================\nThis example can be built from the command prompt with the provided\nMakefile. The "
},
{
"path": "examples/arm-cm/blinky_efm32-slstk3401a/qv/gnu/blinky-qv.ld",
"chars": 4333,
"preview": "/*****************************************************************************\n* Product: Linker script for EFM32-SLSTK3"
},
{
"path": "examples/arm-cm/blinky_efm32-slstk3401a/qv/gnu/flash.bat",
"chars": 1249,
"preview": "::============================================================================\n:: Batch file to program the flash of EFM"
},
{
"path": "examples/arm-cm/blinky_efm32-slstk3401a/qv/iar/README.txt",
"chars": 1848,
"preview": "About this Example\n==================\nThis example demonstrates how to use the IAR EWARM IDE to build\na QP application.\n"
},
{
"path": "examples/arm-cm/blinky_efm32-slstk3401a/qv/iar/blinky-qv.ewd",
"chars": 98423,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<project>\n <fileVersion>3</fileVersion>\n <configuration>\n <name>Debu"
},
{
"path": "examples/arm-cm/blinky_efm32-slstk3401a/qv/iar/blinky-qv.ewp",
"chars": 74143,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<project>\n <fileVersion>3</fileVersion>\n <configuration>\n <name>Debu"
},
{
"path": "examples/arm-cm/blinky_efm32-slstk3401a/qv/iar/blinky-qv.eww",
"chars": 153,
"preview": "<?xml version=\"1.0\" encoding=\"iso-8859-1\"?>\n\n<workspace>\n <project>\n <path>$WS_DIR$\\blinky-qv.ewp</path>\n </project"
},
{
"path": "examples/arm-cm/blinky_efm32-slstk3401a/qv/iar/blinky-qv.icf",
"chars": 1313,
"preview": "/*###ICF### Section handled by ICF editor, don't touch! ****/\n/*-Editor annotation file-*/\n/* IcfEditorFile=\"$TOOLKIT_DI"
},
{
"path": "examples/arm-cm/blinky_ek-tm4c123gxl/README.txt",
"chars": 1565,
"preview": "About this Example\n==================\nThis directory contains the simple \"Blinky\" QP-nano example application for\nthe EK"
},
{
"path": "examples/arm-cm/blinky_ek-tm4c123gxl/README.url",
"chars": 134,
"preview": "[InternetShortcut]\nURL=http://www.state-machine.com/qpn/arm-cm_blinky_ek-tm4c123gxl.html\nIconFile=http://www.state-machi"
},
{
"path": "examples/arm-cm/blinky_ek-tm4c123gxl/blinky.c",
"chars": 3519,
"preview": "/*****************************************************************************\n* Product: Simple Blinky example\n* Last u"
},
{
"path": "examples/arm-cm/blinky_ek-tm4c123gxl/blinky.h",
"chars": 1765,
"preview": "/*****************************************************************************\n* Product: simple \"Blinky\" example\n* Last"
},
{
"path": "examples/arm-cm/blinky_ek-tm4c123gxl/bsp.h",
"chars": 1618,
"preview": "/*****************************************************************************\n* Product: Simple Blinky example\n* Last u"
},
{
"path": "examples/arm-cm/blinky_ek-tm4c123gxl/main.c",
"chars": 2371,
"preview": "/*****************************************************************************\n* Product: \"Blinky\" example\n* Last Update"
},
{
"path": "examples/arm-cm/blinky_ek-tm4c123gxl/qk/arm/README.txt",
"chars": 2005,
"preview": "About this Example\n==================\nThis example demonstrates how to use the uVision IDE together with\nthe MDK-ARM too"
},
{
"path": "examples/arm-cm/blinky_ek-tm4c123gxl/qk/arm/blinky-qk.uvoptx",
"chars": 18099,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\" ?>\n<ProjectOpt xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance"
},
{
"path": "examples/arm-cm/blinky_ek-tm4c123gxl/qk/arm/blinky-qk.uvprojx",
"chars": 34336,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\" ?>\n<Project xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" x"
},
{
"path": "examples/arm-cm/blinky_ek-tm4c123gxl/qk/armclang/README.txt",
"chars": 2005,
"preview": "About this Example\n==================\nThis example demonstrates how to use the uVision IDE together with\nthe MDK-ARM too"
},
{
"path": "examples/arm-cm/blinky_ek-tm4c123gxl/qk/armclang/blinky-qk.uvoptx",
"chars": 18514,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\" ?>\n<ProjectOpt xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance"
},
{
"path": "examples/arm-cm/blinky_ek-tm4c123gxl/qk/armclang/blinky-qk.uvprojx",
"chars": 34812,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\" ?>\n<Project xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" x"
},
{
"path": "examples/arm-cm/blinky_ek-tm4c123gxl/qk/bsp.c",
"chars": 8570,
"preview": "/*****************************************************************************\n* Product: \"Blinky\" on EK-TM4C123GXL boar"
},
{
"path": "examples/arm-cm/blinky_ek-tm4c123gxl/qk/gnu/.ccsproject",
"chars": 659,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n<?ccsproject version=\"1.0\"?>\n<projectOptions>\n\t<ccsVersion value=\"7.4.0\"/>\n\t<dev"
},
{
"path": "examples/arm-cm/blinky_ek-tm4c123gxl/qk/gnu/.cproject",
"chars": 27910,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n<?fileVersion 4.0.0?><cproject storage_type_id=\"org.eclipse.cdt.c"
},
{
"path": "examples/arm-cm/blinky_ek-tm4c123gxl/qk/gnu/.project",
"chars": 3055,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<projectDescription>\n\t<name>blinky-qk</name>\n\t<comment></comment>\n\t<projects>\n\t</"
},
{
"path": "examples/arm-cm/blinky_ek-tm4c123gxl/qk/gnu/Makefile",
"chars": 7902,
"preview": "##############################################################################\n# Product: Makefile for QP-nano on EK-TM4"
},
{
"path": "examples/arm-cm/blinky_ek-tm4c123gxl/qk/gnu/README.txt",
"chars": 2284,
"preview": "About this Example\n==================\nThis example can be built in two different ways:\n- from the command prompt with th"
},
{
"path": "examples/arm-cm/blinky_ek-tm4c123gxl/qk/gnu/blinky-qk.ld",
"chars": 4322,
"preview": "/*****************************************************************************\n* Product: Linker script for EK-TM4C123GX"
},
{
"path": "examples/arm-cm/blinky_ek-tm4c123gxl/qk/gnu/flash.bat",
"chars": 867,
"preview": "::============================================================================\n:: Batch file to program the flash of EK-"
},
{
"path": "examples/arm-cm/blinky_ek-tm4c123gxl/qk/iar/README.txt",
"chars": 1858,
"preview": "About this Example\n==================\nThis example demonstrates how to use the IAR EWARM IDE to build\na QP application.\n"
},
{
"path": "examples/arm-cm/blinky_ek-tm4c123gxl/qk/iar/blinky-qk.ewd",
"chars": 98400,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<project>\n <fileVersion>3</fileVersion>\n <configuration>\n <name>Debu"
},
{
"path": "examples/arm-cm/blinky_ek-tm4c123gxl/qk/iar/blinky-qk.ewp",
"chars": 73486,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<project>\n <fileVersion>3</fileVersion>\n <configuration>\n <name>Debu"
},
{
"path": "examples/arm-cm/blinky_ek-tm4c123gxl/qk/iar/blinky-qk.eww",
"chars": 153,
"preview": "<?xml version=\"1.0\" encoding=\"iso-8859-1\"?>\n\n<workspace>\n <project>\n <path>$WS_DIR$\\blinky-qk.ewp</path>\n </project"
},
{
"path": "examples/arm-cm/blinky_ek-tm4c123gxl/qk/iar/blinky-qk.icf",
"chars": 1313,
"preview": "/*###ICF### Section handled by ICF editor, don't touch! ****/\n/*-Editor annotation file-*/\n/* IcfEditorFile=\"$TOOLKIT_DI"
},
{
"path": "examples/arm-cm/blinky_ek-tm4c123gxl/qpn_conf.h",
"chars": 1702,
"preview": "/*****************************************************************************\n* Product: QP-nano configuration for the "
},
{
"path": "examples/arm-cm/blinky_ek-tm4c123gxl/qv/arm/README.txt",
"chars": 2005,
"preview": "About this Example\n==================\nThis example demonstrates how to use the uVision IDE together with\nthe MDK-ARM too"
},
{
"path": "examples/arm-cm/blinky_ek-tm4c123gxl/qv/arm/blinky-qv.uvoptx",
"chars": 17506,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\" ?>\n<ProjectOpt xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance"
},
{
"path": "examples/arm-cm/blinky_ek-tm4c123gxl/qv/arm/blinky-qv.uvprojx",
"chars": 33971,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\" ?>\n<Project xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" x"
},
{
"path": "examples/arm-cm/blinky_ek-tm4c123gxl/qv/armclang/README.txt",
"chars": 2005,
"preview": "About this Example\n==================\nThis example demonstrates how to use the uVision IDE together with\nthe MDK-ARM too"
},
{
"path": "examples/arm-cm/blinky_ek-tm4c123gxl/qv/armclang/blinky-qv.uvoptx",
"chars": 18094,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\" ?>\n<ProjectOpt xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance"
},
{
"path": "examples/arm-cm/blinky_ek-tm4c123gxl/qv/armclang/blinky-qv.uvprojx",
"chars": 34326,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\" ?>\n<Project xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" x"
},
{
"path": "examples/arm-cm/blinky_ek-tm4c123gxl/qv/bsp.c",
"chars": 8300,
"preview": "/*****************************************************************************\n* Product: \"Blinky\" on EK-TM4C123GXL boar"
},
{
"path": "examples/arm-cm/blinky_ek-tm4c123gxl/qv/gnu/.ccsproject",
"chars": 659,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n<?ccsproject version=\"1.0\"?>\n<projectOptions>\n\t<ccsVersion value=\"7.4.0\"/>\n\t<dev"
},
{
"path": "examples/arm-cm/blinky_ek-tm4c123gxl/qv/gnu/.cproject",
"chars": 27910,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n<?fileVersion 4.0.0?><cproject storage_type_id=\"org.eclipse.cdt.c"
},
{
"path": "examples/arm-cm/blinky_ek-tm4c123gxl/qv/gnu/.project",
"chars": 3055,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<projectDescription>\n\t<name>blinky-qv</name>\n\t<comment></comment>\n\t<projects>\n\t</"
},
{
"path": "examples/arm-cm/blinky_ek-tm4c123gxl/qv/gnu/Makefile",
"chars": 7878,
"preview": "##############################################################################\n# Product: Makefile for QP-nano on EK-TM4"
},
{
"path": "examples/arm-cm/blinky_ek-tm4c123gxl/qv/gnu/README.txt",
"chars": 2284,
"preview": "About this Example\n==================\nThis example can be built in two different ways:\n- from the command prompt with th"
},
{
"path": "examples/arm-cm/blinky_ek-tm4c123gxl/qv/gnu/blinky-qv.ld",
"chars": 4322,
"preview": "/*****************************************************************************\n* Product: Linker script for EK-TM4C123GX"
},
{
"path": "examples/arm-cm/blinky_ek-tm4c123gxl/qv/gnu/flash.bat",
"chars": 867,
"preview": "::============================================================================\n:: Batch file to program the flash of EK-"
},
{
"path": "examples/arm-cm/blinky_ek-tm4c123gxl/qv/iar/README.txt",
"chars": 1856,
"preview": "About this Example\n==================\nThis example demonstrates how to use the IAR EWARM IDE to build\na QP application.\n"
},
{
"path": "examples/arm-cm/blinky_ek-tm4c123gxl/qv/iar/blinky-qv.ewd",
"chars": 98400,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<project>\n <fileVersion>3</fileVersion>\n <configuration>\n <name>Debu"
},
{
"path": "examples/arm-cm/blinky_ek-tm4c123gxl/qv/iar/blinky-qv.ewp",
"chars": 73599,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<project>\n <fileVersion>3</fileVersion>\n <configuration>\n <name>Debu"
},
{
"path": "examples/arm-cm/blinky_ek-tm4c123gxl/qv/iar/blinky-qv.eww",
"chars": 153,
"preview": "<?xml version=\"1.0\" encoding=\"iso-8859-1\"?>\n\n<workspace>\n <project>\n <path>$WS_DIR$\\blinky-qv.ewp</path>\n </project"
},
{
"path": "examples/arm-cm/blinky_ek-tm4c123gxl/qv/iar/blinky-qv.icf",
"chars": 1313,
"preview": "/*###ICF### Section handled by ICF editor, don't touch! ****/\n/*-Editor annotation file-*/\n/* IcfEditorFile=\"$TOOLKIT_DI"
},
{
"path": "examples/arm-cm/dpp_efm32-slstk3401a/README.txt",
"chars": 1801,
"preview": "About this Example\n==================\nThis directory contains the simple DPP QP-nano example application for\nthe EK-TM4C"
},
{
"path": "examples/arm-cm/dpp_efm32-slstk3401a/README.url",
"chars": 134,
"preview": "[InternetShortcut]\nURL=http://www.state-machine.com/qpn/arm-cm_dpp_efm32-slstk3401a.html\nIconFile=http://www.state-machi"
},
{
"path": "examples/arm-cm/dpp_efm32-slstk3401a/bsp.h",
"chars": 1827,
"preview": "/*****************************************************************************\n* Product: DPP example\n* Last Updated for"
},
{
"path": "examples/arm-cm/dpp_efm32-slstk3401a/dpp.h",
"chars": 3072,
"preview": "/*.$file${.::dpp.h} vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv*/\n/*\n* Model: dpp.qm\n* File: ${.::dpp.h}\n*"
},
{
"path": "examples/arm-cm/dpp_efm32-slstk3401a/dpp.qm",
"chars": 14082,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<model version=\"4.6.0\" links=\"1\">\n <documentation>Dining Philosopher Problem exam"
},
{
"path": "examples/arm-cm/dpp_efm32-slstk3401a/main.c",
"chars": 2786,
"preview": "/*****************************************************************************\n* Product: DPP example\n* Last Updated for"
},
{
"path": "examples/arm-cm/dpp_efm32-slstk3401a/philo.c",
"chars": 7744,
"preview": "/*.$file${.::philo.c} vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv*/\n/*\n* Model: dpp.qm\n* File: ${.::philo.c}"
},
{
"path": "examples/arm-cm/dpp_efm32-slstk3401a/qk/armclang/README.txt",
"chars": 1881,
"preview": "About this Example\n==================\nThis example demonstrates how to use the uVision IDE together with\nthe MDK-ARM too"
},
{
"path": "examples/arm-cm/dpp_efm32-slstk3401a/qk/armclang/dpp-qk.uvoptx",
"chars": 20472,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\" ?>\n<ProjectOpt xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance"
},
{
"path": "examples/arm-cm/dpp_efm32-slstk3401a/qk/armclang/dpp-qk.uvprojx",
"chars": 36007,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\" ?>\n<Project xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" x"
},
{
"path": "examples/arm-cm/dpp_efm32-slstk3401a/qk/bsp.c",
"chars": 11525,
"preview": "/*****************************************************************************\n* Product: DPP example, EFM32-SLSTK3401A "
},
{
"path": "examples/arm-cm/dpp_efm32-slstk3401a/qk/gnu/Makefile",
"chars": 7939,
"preview": "##############################################################################\n# Product: Makefile for QP-nano on EMF32-"
},
{
"path": "examples/arm-cm/dpp_efm32-slstk3401a/qk/gnu/README.txt",
"chars": 2238,
"preview": "About this Example\n==================\nThis example can be built from the command prompt with the provided\nMakefile. The "
},
{
"path": "examples/arm-cm/dpp_efm32-slstk3401a/qk/gnu/dpp-qk.ld",
"chars": 4333,
"preview": "/*****************************************************************************\n* Product: Linker script for EFM32-SLSTK3"
},
{
"path": "examples/arm-cm/dpp_efm32-slstk3401a/qk/gnu/flash.bat",
"chars": 1249,
"preview": "::============================================================================\n:: Batch file to program the flash of EFM"
},
{
"path": "examples/arm-cm/dpp_efm32-slstk3401a/qk/iar/README.txt",
"chars": 1848,
"preview": "About this Example\n==================\nThis example demonstrates how to use the IAR EWARM IDE to build\na QP application.\n"
},
{
"path": "examples/arm-cm/dpp_efm32-slstk3401a/qk/iar/dpp-qk.ewd",
"chars": 99425,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<project>\n <fileVersion>3</fileVersion>\n <configuration>\n <name>Debu"
},
{
"path": "examples/arm-cm/dpp_efm32-slstk3401a/qk/iar/dpp-qk.ewp",
"chars": 74816,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<project>\n <fileVersion>3</fileVersion>\n <configuration>\n <name>Debu"
},
{
"path": "examples/arm-cm/dpp_efm32-slstk3401a/qk/iar/dpp-qk.eww",
"chars": 150,
"preview": "<?xml version=\"1.0\" encoding=\"iso-8859-1\"?>\n\n<workspace>\n <project>\n <path>$WS_DIR$\\dpp-qk.ewp</path>\n </project>\n "
},
{
"path": "examples/arm-cm/dpp_efm32-slstk3401a/qk/iar/dpp-qk.icf",
"chars": 1313,
"preview": "/*###ICF### Section handled by ICF editor, don't touch! ****/\n/*-Editor annotation file-*/\n/* IcfEditorFile=\"$TOOLKIT_DI"
},
{
"path": "examples/arm-cm/dpp_efm32-slstk3401a/qpn_conf.h",
"chars": 1724,
"preview": "/*****************************************************************************\n* Product: QP-nano configuration for the "
},
{
"path": "examples/arm-cm/dpp_efm32-slstk3401a/qv/armclang/README.txt",
"chars": 1881,
"preview": "About this Example\n==================\nThis example demonstrates how to use the uVision IDE together with\nthe MDK-ARM too"
},
{
"path": "examples/arm-cm/dpp_efm32-slstk3401a/qv/armclang/dpp-qv.uvoptx",
"chars": 20472,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\" ?>\n<ProjectOpt xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance"
},
{
"path": "examples/arm-cm/dpp_efm32-slstk3401a/qv/armclang/dpp-qv.uvprojx",
"chars": 36007,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\" ?>\n<Project xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" x"
},
{
"path": "examples/arm-cm/dpp_efm32-slstk3401a/qv/bsp.c",
"chars": 10972,
"preview": "/*****************************************************************************\n* Product: DPP example, EFM32-SLSTK3401A "
},
{
"path": "examples/arm-cm/dpp_efm32-slstk3401a/qv/gnu/Makefile",
"chars": 7942,
"preview": "##############################################################################\n# Product: Makefile for QP-nano on EMF32-"
},
{
"path": "examples/arm-cm/dpp_efm32-slstk3401a/qv/gnu/README.txt",
"chars": 2238,
"preview": "About this Example\n==================\nThis example can be built from the command prompt with the provided\nMakefile. The "
},
{
"path": "examples/arm-cm/dpp_efm32-slstk3401a/qv/gnu/dpp-qv.ld",
"chars": 4333,
"preview": "/*****************************************************************************\n* Product: Linker script for EFM32-SLSTK3"
},
{
"path": "examples/arm-cm/dpp_efm32-slstk3401a/qv/gnu/flash.bat",
"chars": 1249,
"preview": "::============================================================================\n:: Batch file to program the flash of EFM"
},
{
"path": "examples/arm-cm/dpp_efm32-slstk3401a/qv/iar/README.txt",
"chars": 1848,
"preview": "About this Example\n==================\nThis example demonstrates how to use the IAR EWARM IDE to build\na QP application.\n"
},
{
"path": "examples/arm-cm/dpp_efm32-slstk3401a/qv/iar/dpp-qv.ewd",
"chars": 98423,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<project>\n <fileVersion>3</fileVersion>\n <configuration>\n <name>Debu"
},
{
"path": "examples/arm-cm/dpp_efm32-slstk3401a/qv/iar/dpp-qv.ewp",
"chars": 74399,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<project>\n <fileVersion>3</fileVersion>\n <configuration>\n <name>Debu"
},
{
"path": "examples/arm-cm/dpp_efm32-slstk3401a/qv/iar/dpp-qv.eww",
"chars": 150,
"preview": "<?xml version=\"1.0\" encoding=\"iso-8859-1\"?>\n\n<workspace>\n <project>\n <path>$WS_DIR$\\dpp-qv.ewp</path>\n </project>\n "
},
{
"path": "examples/arm-cm/dpp_efm32-slstk3401a/qv/iar/dpp-qv.icf",
"chars": 1313,
"preview": "/*###ICF### Section handled by ICF editor, don't touch! ****/\n/*-Editor annotation file-*/\n/* IcfEditorFile=\"$TOOLKIT_DI"
},
{
"path": "examples/arm-cm/dpp_efm32-slstk3401a/table.c",
"chars": 10096,
"preview": "/*.$file${.::table.c} vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv*/\n/*\n* Model: dpp.qm\n* File: ${.::table.c}"
},
{
"path": "examples/arm-cm/dpp_efm32-slstk3401a/win32-gui/bsp.c",
"chars": 9959,
"preview": "/*****************************************************************************\n* Product: \"DPP\" example, EFM32-SLSTK3401"
},
{
"path": "examples/arm-cm/dpp_efm32-slstk3401a/win32-gui/dpp-gui.sln",
"chars": 961,
"preview": "Microsoft Visual Studio Solution File, Format Version 12.00\n# Visual Studio Express 2013 for Windows Desktop\nVisualStudi"
},
{
"path": "examples/arm-cm/dpp_efm32-slstk3401a/win32-gui/dpp-gui.vcxproj",
"chars": 9287,
"preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<Project DefaultTargets=\"Build\" ToolsVersion=\"12.0\" xmlns=\"http://schemas.microso"
},
{
"path": "examples/arm-cm/dpp_efm32-slstk3401a/win32-gui/dpp-gui.vcxproj.filters",
"chars": 1772,
"preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<Project ToolsVersion=\"4.0\" xmlns=\"http://schemas.microsoft.com/developer/msbuil"
},
{
"path": "examples/arm-cm/dpp_efm32-slstk3401a/win32-gui/resource.h",
"chars": 1149,
"preview": "//{{NO_DEPENDENCIES}}\n// Microsoft Visual C++ generated include file.\n// Used by Resource.rc\n//\n#define IDI_QP "
},
{
"path": "examples/arm-cm/dpp_ek-tm4c123gxl/README.txt",
"chars": 1801,
"preview": "About this Example\n==================\nThis directory contains the simple DPP QP-nano example application for\nthe EK-TM4C"
},
{
"path": "examples/arm-cm/dpp_ek-tm4c123gxl/README.url",
"chars": 131,
"preview": "[InternetShortcut]\nURL=http://www.state-machine.com/qpn/arm-cm_dpp_ek-tm4c123gxl.html\nIconFile=http://www.state-machine."
},
{
"path": "examples/arm-cm/dpp_ek-tm4c123gxl/bsp.h",
"chars": 1827,
"preview": "/*****************************************************************************\n* Product: DPP example\n* Last Updated for"
},
{
"path": "examples/arm-cm/dpp_ek-tm4c123gxl/dpp.h",
"chars": 3072,
"preview": "/*.$file${.::dpp.h} vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv*/\n/*\n* Model: dpp.qm\n* File: ${.::dpp.h}\n*"
},
{
"path": "examples/arm-cm/dpp_ek-tm4c123gxl/dpp.qm",
"chars": 14082,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<model version=\"4.6.0\" links=\"1\">\n <documentation>Dining Philosopher Problem exam"
},
{
"path": "examples/arm-cm/dpp_ek-tm4c123gxl/lint-plus/README.txt",
"chars": 866,
"preview": "About this Example\n==================\nThis directory contains the facilities for \"linting\" the application with\nPC-Lint-"
},
{
"path": "examples/arm-cm/dpp_ek-tm4c123gxl/lint-plus/lin.bat",
"chars": 2169,
"preview": "@echo off\n:: ===========================================================================\n:: Product: QP-nano build scrip"
},
{
"path": "examples/arm-cm/dpp_ek-tm4c123gxl/lint-plus/options.lnt",
"chars": 2675,
"preview": "//////////////////////////////////////////////////////////////////////////////\n// Product: PC-Lint-Plus options for lint"
},
{
"path": "examples/arm-cm/dpp_ek-tm4c123gxl/main.c",
"chars": 2786,
"preview": "/*****************************************************************************\n* Product: DPP example\n* Last Updated for"
},
{
"path": "examples/arm-cm/dpp_ek-tm4c123gxl/philo.c",
"chars": 7744,
"preview": "/*.$file${.::philo.c} vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv*/\n/*\n* Model: dpp.qm\n* File: ${.::philo.c}"
},
{
"path": "examples/arm-cm/dpp_ek-tm4c123gxl/qk/arm/README.txt",
"chars": 2007,
"preview": "About this Example\n==================\nThis example demonstrates how to use the uVision IDE together with\nthe MDK-ARM too"
},
{
"path": "examples/arm-cm/dpp_ek-tm4c123gxl/qk/arm/dpp-qk.uvoptx",
"chars": 19102,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\" ?>\n<ProjectOpt xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance"
},
{
"path": "examples/arm-cm/dpp_ek-tm4c123gxl/qk/arm/dpp-qk.uvprojx",
"chars": 35243,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\" ?>\n<Project xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" x"
},
{
"path": "examples/arm-cm/dpp_ek-tm4c123gxl/qk/armclang/README.txt",
"chars": 2007,
"preview": "About this Example\n==================\nThis example demonstrates how to use the uVision IDE together with\nthe MDK-ARM too"
},
{
"path": "examples/arm-cm/dpp_ek-tm4c123gxl/qk/armclang/dpp-qk.uvoptx",
"chars": 19236,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\" ?>\n<ProjectOpt xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance"
},
{
"path": "examples/arm-cm/dpp_ek-tm4c123gxl/qk/armclang/dpp-qk.uvprojx",
"chars": 35417,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\" ?>\n<Project xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" x"
},
{
"path": "examples/arm-cm/dpp_ek-tm4c123gxl/qk/bsp.c",
"chars": 11634,
"preview": "/*****************************************************************************\n* Product: DPP on EK-TM4C123GXL board, pr"
},
{
"path": "examples/arm-cm/dpp_ek-tm4c123gxl/qk/gnu/.ccsproject",
"chars": 659,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n<?ccsproject version=\"1.0\"?>\n<projectOptions>\n\t<ccsVersion value=\"7.4.0\"/>\n\t<dev"
},
{
"path": "examples/arm-cm/dpp_ek-tm4c123gxl/qk/gnu/.cproject",
"chars": 27907,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n<?fileVersion 4.0.0?><cproject storage_type_id=\"org.eclipse.cdt.c"
},
{
"path": "examples/arm-cm/dpp_ek-tm4c123gxl/qk/gnu/.project",
"chars": 3164,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<projectDescription>\n\t<name>dpp-qk</name>\n\t<comment></comment>\n\t<projects>\n\t</pro"
},
{
"path": "examples/arm-cm/dpp_ek-tm4c123gxl/qk/gnu/Makefile",
"chars": 7885,
"preview": "##############################################################################\n# Product: Makefile for QP-nano on EK-TM4"
},
{
"path": "examples/arm-cm/dpp_ek-tm4c123gxl/qk/gnu/README.txt",
"chars": 2284,
"preview": "About this Example\n==================\nThis example can be built in two different ways:\n- from the command prompt with th"
},
{
"path": "examples/arm-cm/dpp_ek-tm4c123gxl/qk/gnu/dpp-qk.ld",
"chars": 4322,
"preview": "/*****************************************************************************\n* Product: Linker script for EK-TM4C123GX"
},
{
"path": "examples/arm-cm/dpp_ek-tm4c123gxl/qk/gnu/flash.bat",
"chars": 867,
"preview": "::============================================================================\n:: Batch file to program the flash of EK-"
},
{
"path": "examples/arm-cm/dpp_ek-tm4c123gxl/qk/iar/README.txt",
"chars": 1858,
"preview": "About this Example\n==================\nThis example demonstrates how to use the IAR EWARM IDE to build\na QP application.\n"
},
{
"path": "examples/arm-cm/dpp_ek-tm4c123gxl/qk/iar/dpp-qk.ewd",
"chars": 98400,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<project>\n <fileVersion>3</fileVersion>\n <configuration>\n <name>Debu"
},
{
"path": "examples/arm-cm/dpp_ek-tm4c123gxl/qk/iar/dpp-qk.ewp",
"chars": 76696,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<project>\n <fileVersion>3</fileVersion>\n <configuration>\n <name>Debu"
},
{
"path": "examples/arm-cm/dpp_ek-tm4c123gxl/qk/iar/dpp-qk.eww",
"chars": 150,
"preview": "<?xml version=\"1.0\" encoding=\"iso-8859-1\"?>\n\n<workspace>\n <project>\n <path>$WS_DIR$\\dpp-qk.ewp</path>\n </project>\n "
},
{
"path": "examples/arm-cm/dpp_ek-tm4c123gxl/qk/iar/dpp-qk.icf",
"chars": 1313,
"preview": "/*###ICF### Section handled by ICF editor, don't touch! ****/\n/*-Editor annotation file-*/\n/* IcfEditorFile=\"$TOOLKIT_DI"
},
{
"path": "examples/arm-cm/dpp_ek-tm4c123gxl/qpn_conf.h",
"chars": 1724,
"preview": "/*****************************************************************************\n* Product: QP-nano configuration for the "
},
{
"path": "examples/arm-cm/dpp_ek-tm4c123gxl/qv/arm/README.txt",
"chars": 2007,
"preview": "About this Example\n==================\nThis example demonstrates how to use the uVision IDE together with\nthe MDK-ARM too"
},
{
"path": "examples/arm-cm/dpp_ek-tm4c123gxl/qv/arm/dpp-qv.uvoptx",
"chars": 18073,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\" ?>\n<ProjectOpt xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance"
},
{
"path": "examples/arm-cm/dpp_ek-tm4c123gxl/qv/arm/dpp-qv.uvprojx",
"chars": 34380,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\" ?>\n<Project xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" x"
},
{
"path": "examples/arm-cm/dpp_ek-tm4c123gxl/qv/armclang/README.txt",
"chars": 2007,
"preview": "About this Example\n==================\nThis example demonstrates how to use the uVision IDE together with\nthe MDK-ARM too"
},
{
"path": "examples/arm-cm/dpp_ek-tm4c123gxl/qv/armclang/dpp-qv.uvoptx",
"chars": 19112,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\" ?>\n<ProjectOpt xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance"
},
{
"path": "examples/arm-cm/dpp_ek-tm4c123gxl/qv/armclang/dpp-qv.uvprojx",
"chars": 35293,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\" ?>\n<Project xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" x"
},
{
"path": "examples/arm-cm/dpp_ek-tm4c123gxl/qv/bsp.c",
"chars": 10675,
"preview": "/*****************************************************************************\n* Product: DPP on EK-TM4C123GXL board, co"
},
{
"path": "examples/arm-cm/dpp_ek-tm4c123gxl/qv/gnu/.ccsproject",
"chars": 659,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n<?ccsproject version=\"1.0\"?>\n<projectOptions>\n\t<ccsVersion value=\"7.4.0\"/>\n\t<dev"
}
]
// ... and 628 more files (download for full content)
About this extraction
This page contains the full source code of the QuantumLeaps/qpn GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 828 files (8.9 MB), approximately 2.4M tokens, and a symbol index with 1228 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.