RMOS3 real-time operating system. RMOS3 GNU V3.0 Development Platform. Programming and Operating Manual 07/2009 RMOS3. Answers for industry.

Transcription

1 RMOS3 real-time operating system Programming and Operating Manual 07/2009 RMOS3 Answers for industry.

2

3 RMOS3 GNU V3.0 Development Platform RMOS3 RMOS3 real-time operating system RMOS3 GNU V3.0 Development Platform Programming and Operating Manual Introduction 1 Description 2 Installation 3 Operator control 4 Testing an RMOS3 application 5 Diagnostics 6 Converting from RMOS3- GNU V2.x to V3.0 7 Example of application generation 8 A Appendix B List of abbreviations 07/2009 A5E

4 Legal information Legal information Warning notice system This manual contains notices you have to observe in order to ensure your personal safety, as well as to prevent damage to property. The notices referring to your personal safety are highlighted in the manual by a safety alert symbol, notices referring only to property damage have no safety alert symbol. These notices shown below are graded according to the degree of danger. DANGER indicates that death or severe personal injury will result if proper precautions are not taken. WARNING indicates that death or severe personal injury may result if proper precautions are not taken. CAUTION with a safety alert symbol, indicates that minor personal injury can result if proper precautions are not taken. CAUTION without a safety alert symbol, indicates that property damage can result if proper precautions are not taken. NOTICE indicates that an unintended result or situation can occur if the relevant information is not taken into account. If more than one degree of danger is present, the warning notice representing the highest degree of danger will be used. A notice warning of injury to persons with a safety alert symbol may also include a warning relating to property damage. Qualified Personnel The product/system described in this documentation may be operated only by personnel qualified for the specific task in accordance with the relevant documentation, in particular its warning notices and safety instructions. Qualified personnel are those who, based on their training and experience, are capable of identifying risks and avoiding potential hazards when working with these products/systems. Proper use of Siemens products Note the following: WARNING Siemens products may only be used for the applications described in the catalog and in the relevant technical documentation. If products and components from other manufacturers are used, these must be recommended or approved by Siemens. Proper transport, storage, installation, assembly, commissioning, operation and maintenance are required to ensure that the products operate safely and without any problems. The permissible ambient conditions must be complied with. The information in the relevant documentation must be observed. Trademarks All names identified by are registered trademarks of Siemens AG. The remaining trademarks in this publication may be trademarks whose use by third parties for their own purposes could violate the rights of the owner. Disclaimer of Liability We have reviewed the contents of this publication to ensure consistency with the hardware and software described. Since variance cannot be precluded entirely, we cannot guarantee full consistency. However, the information in this publication is reviewed regularly and any necessary corrections are included in subsequent editions. Siemens AG Industry Sector Postfach NÜRNBERG GERMANY A5E P 05/2012 Technical data subject to change Copyright Siemens AG All rights reserved

5 Table of contents 1 Introduction Content and purpose of this documentation Target group History of changes in this documentation Formatting Description Product Overview New functions in RMOS3-GNU V System requirements Tool versions Installation Installation of the development environment Configuring the target system Operator control Creating applications from the command line C compiler C++ compiler Assembler Library manager Deleting files Linker for implicit binding Linker for explicit binding Strip tool Defining the stack size make Creating applications under the Eclipse IDE Starting the Eclipse IDE C/C++ view Setting up the workbench Creating an application Importing example projects Transfer the application to the target system Project type Executable (GNU on RMOS) Project type Static Library (GNU on RMOS) Code completion Downloading with FTP Using the Remote Launcher RMOS3 help...50 Programming and Operating Manual, 07/2009, A5E

6 Table of contents 5 Testing an RMOS3 application Testing on the target system Testing from the command line Starting the GDB server Testing with the GDB client Testing with the Eclipse IDE debugger RMOS3 simulation on the development PC Objective of the RMOS3 simulation Restrictions and limits Quantity framework Priority behavior Existing functions Supported functions Restricted supported functions Unsupported functions Usage with the Eclipse IDE Settings Debugging Generating for the target system Diagnostics Preference settings Terminal Profiling The Load Distribution view The Task Activity view Converting from RMOS3-GNU V2.x to V Example of application generation Description of example Creating the MyGnu project Creating the C program file Entering the C program Setting the compiler parameters Setting the linker parameters Setting the assembler parameters Activating the project settings Configuring the strip tool Building the project A Appendix A.1 Useful documents and links B List of abbreviations Index Programming and Operating Manual, 07/2009, A5E

7 Introduction Content and purpose of this documentation This documentation conveys the basic and necessary knowledge in order to be able to create and test applications for the RMOS3 real-time operating system with the aid of the GNU-based tool chain. It is assumed the reader is familiar with the content of the RMOS3 system manual and the RMOS3 user manual. You also need basic knowledge with regard to the topics of C and C++. See also Useful documents and links (Page 111) 1.2 Target group This documentation is aimed at engineers and programmers who are basically familiar with the real-time operating system RMOS History of changes in this documentation Revision level 1) Overview of changes Release date A1 RMOS3-GNU V1.0 03/2004 A2 RMOS3-GNU V2.0 06/2005 A3 RMOS3-GNU V2.1 04/2007 A4 RMOS3-GNU V3.0 07/2009 1) Corresponds with the 4th block of the drawing number Programming and Operating Manual, 07/2009, A5E

8 Introduction 1.4 Formatting 1.4 Formatting System console output to the target system or development system are marked as follows: Output text User input, directory and file names are marked as followed: User input, directory and file names 6 Programming and Operating Manual, 07/2009, A5E

9 Description Product Overview Product structure Figure 2-1 RMOS3-GNU V3.0 product structure The GNU-based tool chain is an open source development environment that essentially comprises a compiler for C/C++, a make tool, an assembler, a linker and a debugger. It was originally developed for UNIX, but with the aid of the MSYS/MinGW adaption layer, it can now run on Windows systems. Programming and Operating Manual, 07/2009, A5E

10 Description 2.1 Product Overview New functions in RMOS3-GNU V3.0 New functions in RMOS3-GNU V3.0 The following new functions are included in RMOS3-GNU V3.0: More recent versions of the tools (for example: C compiler). The Eclipse plug-in "Terminal" enables remote operation of the target system via TELNET from the Eclipse IDE. The Eclipse plug-in "Profiling" enables load measurements and measurement of task activities on the target system from the Eclipse IDE. The Cygwin adaption layer was replaced with the MSYS/MinGW adaption layer. New functions in Eclipse SDK The new functions in Eclipse SDK are available at: eclipse Homepage ( Available versions Product name MLFB Supplied on CD RMOS3-GNU V3.0 (for first installation) RMOS3-GNU V3.0 Update (for customers who have already purchased a license for RMOS3- GNU V2.x) 6AR1405-0BA00-1CA0 6AR1405-0BA50-1CA0 GNU tool chain GNU expansion ECLIPSE IDE GNU debug server GNU tool chain GNU expansion ECLIPSE IDE GNU debug server Licenses The GNU-based tool chain, the GNU Debug server as well as the Eclipse IDE are subject to different open source licenses. Please observe the licensing text included with the product. 8 Programming and Operating Manual, 07/2009, A5E

11 Description 2.2 System requirements 2.2 System requirements Development system Windows XP or Windows Vista (32-bit) RAM 256 MB, clock frequency 1 GHz Java Runtime Environment as of version 1.5 (only when using the Eclipse IDE) RMOS3 development tree as of RMOS3 Version 3.40 including software fix RMOS3 V or RMOS3 V3.50 including software fix RMOS3 V Target system RMOS3 as of version or version Tool versions The original GNU tools are required for the RMOS3 simulation. They are called gcc or g++. The tools for generating applications for the RMOS3 target system bear the prefix rm-. Tool versions gcc Reading specs from C:/msys/1.0/mingw/bin/../lib/gcc/mingw32/3.4.5/specs Thread model: win32 gcc version (mingw-vista special r3) rm-gcc Reading specs from c:/msys/1.0/local/bin/../lib/gcc/i586-rmoself/4.3.0/specs Target: i586-rmos-elf Configured with:../gcc-4.3.0/configure --target=i586-rmos-elf --withoutheaders Thread model: single gcc version (GCC) g++ Reading specs from C:/msys/1.0/mingw/bin/../lib/gcc/mingw32/3.4.5/specs Thread model: win32 gcc version (mingw-vista special r3) Programming and Operating Manual, 07/2009, A5E

12 Description 2.3 Tool versions rm-g++ Reading specs from c:/msys/1.0/local/bin/../lib/gcc/i586-rmoself/4.3.0/specs Target: i586-rmos-elf Configured with:../gcc-4.3.0/configure --target=i586-rmos-elf --withoutheaders Thread model: single gcc version (GCC) ld GNU ld version rm-id GNU ld (GNU Binutils) 2.18 ar GNU ar rm-ar GNU ar (GNU Binutils) 2.18 as GNU assembler version (mingw32) using BFD version rm-as GNU assembler version 2.18 (i586-rmos-elf) using BFD version (GNU Binutils) 2.18 make GNU Make version , by Richard Stallman and Roland McGrath. Built for i686-pc-msys gdb GNU gdb 6.8 This GDB was configured as "i686-pc-mingw32". rm-gdb GNU gdb 6.8 (adjusted for RMOS by Siemens AG, I IA SE, Mar ) This GDB was configured as "--host=i686-pc-mingw32 --target=i586- rmos-elf". rm-strip GNU strip Eclipse IDE eclipse SDK (win32) Eclipse CDT plug-in eclipse CDT (win32) 10 Programming and Operating Manual, 07/2009, A5E

13 Installation Installation of the development environment The development environment can be operated both via the command line as well as via the Eclipse IDE, a JAVA-based user interface. With the Eclipse IDE you must have first installed the JAVA Runtime Environment (JRE). The installation of the Eclipse IDE is optional. Installation of the JRE (Java Runtime Environment) If you want to create an application with the Eclipse IDE, download a current version of the JRE 1.5 or higher from SUN ( and install it. The necessary steps for doing this are specified at the given address. Installation of the development environment NOTICE To install the RMOS3-GNU you require administrator rights to the computer upon which you wish to install the product. Programming and Operating Manual, 07/2009, A5E

14 Installation 3.1 Installation of the development environment Insert the CD, launch the file Setup.exe from the CD and acknowledge the individual installation steps. During the installation in the following form you must choose between a complete or custom installation. Figure 3-1 Selection options during the installation If you select Complete 1 (Figure Selection options during the installation), the GNU expansions for RMOS3, the GNU tool chain and the Eclipse IDE are installed in the directory <rmos_dir> (for example, c:\rm3dev). If you select Custom 2 (Figure Selection options during the installation) each component can be installed as an option and the installation directory can be specified for each component to be installed. NOTICE When installing the RMOS3 components, the sources files of some C examples and the header files will be overwritten (see READ_GNU.3P0 on the installation CD). Note After the successful installation, the directory structure of the GNU expansions for RMOS3 can be found under <rmos_dir>\read_gnu.3p0 (for example, c:\rm3dev\read_gnu.3p0) on the development system. 12 Programming and Operating Manual, 07/2009, A5E

15 Installation 3.1 Installation of the development environment Figure 3-2 Selection options during the user-defined installation Environment variables When installing the component GNU Add-On for RMOS the following environment variables are set: RMOS_HOME PATH This variable is set to the directory in which the RMOS3 tree is installed. The default value is C:/RM3DEV. This environment variable is expanded by the following entry: $(RMOS_HOME)\simulation\bin; When installing the GNU Tools component, the following environment variable is set: MSYS_HOME This environment variable is set to the directory in which the MSYS / MinGW tree (GNU tools) is installed. The default value is $(RMOS_HOME)/msys. NOTICE It is absolutely necessary to set these environment variables. The environment variables RMOS_HOME and MSYS_HOME must include "/", the environment variable PATH includes "\". Start menu and links on the Windows desktop To launch the Eclipse IDE and to open the manuals an entry is made in the Windows start menu. For the Eclipse IDE a link is also set up on the Windows desktop. Programming and Operating Manual, 07/2009, A5E

16 Installation 3.2 Configuring the target system Checking the installation With the aid of the following calls you can ensure that the supplied tools have been correctly installed on the development system. Check to see if the text areas marked in bold are in the message text of the tools: Command line make -v rm-gcc -v rm-g++ -v Message GNU Make version , Configured with:../gcc-4.3.0/configure --target=i586-rmos-elf --without-headers gcc version (GCC) Configured with:../gcc-4.3.0/configure --target=i586-rmos-elf --without-headers gcc version (GCC) rm-as -version GNU assembler (GNU Binutils) 2.18 This assembler was configured for a target of 'i586-rmos-elf'. Directories of the header and library files After successful installation of RMOS3-GNU V3.0, the header and library files are located in the directories of the development tree. The content of the development tree is described in the file <rmos_dir>\read_gnu.3p0 on the development system. 3.2 Configuring the target system Installation of the GDB server on the target system To install the GDB server, the file <rmos_dir>\bin\gdbsrvgn.386 must be copied to the target system in the directory of the RMOS3 run-time environment (for example, C:\RM3RUN or C:\BIN). Installation of the profiler on the target system To install the profiler, the file <rmos_dir>\bin\rprof.386 must be copied to the target system in the directory of the RMOS3 run-time environment (for example, C:\RM3RUN or C:\BIN). 14 Programming and Operating Manual, 07/2009, A5E

17 Operator control 4 You can create applications for RMOS3 by using the GNU tool chain. To do this, both command line programs as well as the Eclipse IDE development interface can be used. 4.1 Creating applications from the command line Operational sequence for creating applications When using C, C++ or the assembler, the following operational sequences arise: Figure 4-1 Creating applications from the command line The GNU tool chain has been modified for creating RMOS3 applications. This is why the modified tools have the names rm-<toolname>.exe, for example, rm-gcc.exe, while the original GNU tools are called <toolname>.exe, for example, gcc.exe. Programming and Operating Manual, 07/2009, A5E

18 Operator control 4.1 Creating applications from the command line C compiler Call of the compiler The C compiler is called to compile with the following syntax from the command line: rm-gcc <Parameter list> <File>.c NOTICE When creating or copying C source code files, ensure that the.c file extension is written in lowercase, otherwise the C++ compiler will be used. Applicable parameters If necessary, the following parameters should be set for compiling RMOS3 applications: Parameters Description -c The source files will only be compiled. The binding process must be explicitly called. -I<inc_dir> The directory <inc_dir> is added to the include path. -ggdb A debug version is created. -o <object file>.o The file <object file>.o is created as an object file. -O<level> -Wall -fno-common -Wa,-a[<sub-option>] =<list file> The optimization of the level <level> is used. All warnings are issued. Correct display of global variables The list file <list file> is created. NOTICE The parameter -c must always be used when translating. Otherwise, automatic binding is triggered after the compiling process, and this fails. Note To create a debug version, use the ggdb option instead of the g option for the previous versions, RMOS3-GNU V2.x. List files can be created for the C source files with the -a option: -a[<sub-option...>] The default for the sub-options is hls. 16 Programming and Operating Manual, 07/2009, A5E

19 Operator control 4.1 Creating applications from the command line Sub-option c d h l m n s =<list file> Description Skip non-fulfilled specific compilings Skip debug commands Add source information Add assembler codings Expand listing with macro expansions Skip formatting (for example, page references) Add symbol information Save the listing in the <list file> file (must be the last sub-option) Example for make files: rm-gcc O0 -Wa,-adhls=$*.lst <File>.c You can find a description of how to create list files from the Eclipse environment in the section Setting the compiler parameters. Note The code optimization should be deactivated when creating list files (-O0). The optimizer may otherwise adjust the code so that a C command can be distributed across various places in the assembler output, with assembler statements from other C commands in-between. Notes on the C compiler Note The optimization has been improved further in version V4.3.0 of the gcc. If optimization is enabled, the compiler calculates the result of simple loops beforehand, for example, and returns the result immediately. Subprograms should not be used as wait loops for this reason. Note The compiler directly calculates mathematical functions with constants and no longer uses functions. This means the result may deviate slightly. If you want to prevent this from happening, you must set the -fno-builtin switch. If the get2ndparam function is used to determine the start parameters of a task, optimization may not be enabled. Information on the C compiler A more detailed description of the C compiler and its parameters can be found on the development system under <rmos_dir>\doc\gcc.pdf. See also Setting the compiler parameters (Page 98) Programming and Operating Manual, 07/2009, A5E

20 Operator control 4.1 Creating applications from the command line C++ compiler Calling the C++ compiler The C++ compiler is called from the command line using the following syntax: rm-g++ <Parameter list> <File>.cc If necessary, you can use the same parameters as those used for the C compiler. Applicable parameters If necessary, the following parameters should be set for compiling RMOS3 applications: Parameter Description -c The source files will only be compiled. The binding process must be explicitly called. -I<inc_dir> The directory <inc_dir> is added to the include path. -ggdb A debug version is created. -o <object file>.o The file <object file>.o is created as an object file. -O<level> -Wall -fno-common -Wa,-a[<sub-option>] =<list file> The optimization of the level <level> is used. All warnings are issued. Correct display of global variables The list file <list file> is created. NOTICE The parameter -c must always be used when translating. Otherwise, automatic binding is triggered after the compiling process, and this fails. Note To create a debug version, use the ggdb option instead of the g option for the previous versions, RMOS3-GNU V2.x. Note The code optimization should be deactivated when creating list files (-O0). The optimizer may otherwise adjust the code so that a C command can be distributed across various places in the assembler output, with assembler statements from other C commands in-between. 18 Programming and Operating Manual, 07/2009, A5E

21 Operator control 4.1 Creating applications from the command line Notes on the C++ compiler Note The optimization has been improved further in version V4.3.0 of the g++. If optimization is enabled, the compiler calculates the result of simple loops beforehand, for example, and returns the result immediately. Subprograms should not be used as wait loops for this reason. NOTICE If the get2ndparam function is used to determine the start parameters of a task, optimization may not be enabled. Information on the C++ compiler A more detailed description of the g++ parameters can be found on the development system under <rmos_dir>\doc\gcc.pdf Assembler Call of the assembler Use the GNU tool rm-as to compile the assembler files. The assembler is called from the command line using the following syntax: rm-as <Parameter list> <File>.s NOTICE The syntax of the GNU assembler is different to that of the Intel/CADUL assembler. Applicable parameters If necessary, the following parameters should be set for compiling assembler files: Parameter Description -o <object file>.o The output file <object file>.o is created. -I <inc_dir> The directory <inc_dir> is added to the include path. -a=<list file> The list file <list file> is created. List files can be created for the assembler source files with the -a option. Example: rm-as -a=myfile.lst <File>.s Programming and Operating Manual, 07/2009, A5E

22 Operator control 4.1 Creating applications from the command line Information on the assembler A more detailed description of the assembler and its parameters can be found on the development system under <rmos_dir>\doc\as.pdf Library manager Calling the library manager The GNU tool rm-ar creates or changes archive files and is called from the command line with the following syntax: rm-ar <Parameter list> <Library> <Object files> Parameters Description -r Already existing files in the archive will be overwritten, new files added. Information on the library manager A more detailed description of the library manager and its parameters can be found on the development system under <rmos_dir>\doc\binutils.pdf Deleting files Calling rm The GNU tool rm is used within make files to delete files. Use the following syntax to call up the rm tool from the command line: rm <File> If you want to delete all *.386 files, use the following syntax: rm $(wildcard *.386) Information on the rm tool A more detailed description of the rm tool and its parameters can be found on the development system under <rmos_dir>\doc\rm.pdf. 20 Programming and Operating Manual, 07/2009, A5E

23 Operator control 4.1 Creating applications from the command line Linker for implicit binding The GNU tools rm-gcc or rm-g++ include linkers for implicit binding. With implicit binding, the system object files are bound automatically. Implicit binding process with rm-gcc and rm-g++ The implicit binding process is called from the command line using the following syntax: rm-gcc <Parameter list> <Object files> <Libraries> Parameters for implicit binding If necessary, the following parameters should be set for implicit binding of RMOS3 applications: Parameter -nodefaultlibs -L<lib_dir> -l<lib> -Xlinker -r -Xlinker --emit-relocs -Xlinker --script -Xlinker i586-rmos-elf.xr Description No system files are automatically bound in. The directory <inc_dir> is added to the library path. The library <lib> is linked to the output file. A debug version is created. A release version is created. Use a linker script to correctly display local and global constant variables -o <program>.386 The file <program>.386 is created as the executable program. -Wl,-Map,<map file> The file <map file> is created. NOTICE If an application is built as a debug version (linker parameter -Xlinker -r), then the linker in its current version does not detect any unresolved references (unresolved externals)! When loading into the target system the unresolved references are detected by the GDB server or the RMOS3. The following standard libraries can be integrated if required: Parameter Meaning Is used at: -lstdc++ Standard C++ library C++ applications -lgcc Compiler-specific library Always -lfastg FastTimerTick library Use of FastTimerTick functions -lclig CLI library Use of CLI commands -lcrig CRUN library Use of CRUN commands -lhlig RMOS3 library Use of nucleus calls -lskifg Socket library Use of socket functions (not included in the delivery scope) Programming and Operating Manual, 07/2009, A5E

24 Operator control 4.1 Creating applications from the command line Linker for explicit binding The GNU tool rm-ld is the linker with the help of which RMOS3 applications (*.386- or*.exefiles) can be bound together from the individual object files (*.o files) and libraries (*.a-files). Explicit binding process with rm-ld The explicit binding process is called from the command line using the following syntax: rm-ld <Parameter list> -o <Output file>.386 <Start objects> <Object files> <Libraries> <End objects> The complete path has to be indicated for start and end objects. The start objects, end objects, object files and libraries must be used in the following order: 1. crt0.o crtbegin.o 2. <Application-specific object files> 3. <Standard libraries> refer to section Linkers for implicit binding 4. crtend.o crtn.o Parameters for explicit binding If necessary, the following parameters should be set for explicit binding of RMOS3 applications: Parameter Description -nostdlibs The standard paths for library files are ignored. -L<lib_dir> The directory <inc_dir> is added to the library path. -l<lib> The library file lib<lib>.a is linked to the output file. -Xlinker --emit-relocs A release version is created. -r A debug version is created. -Map,<map file> A map file <map file> is created. -o <program>.386 The file <program>.386 is created as the executable program. --script i586-rmoself.xr Use a linker script to correctly display local and global constant variables Information on Id A more detailed description of the linker and its parameters can be found on the development system under <rmos_dir>\doc\ld.pdf. See also Linker for implicit binding (Page 21) 22 Programming and Operating Manual, 07/2009, A5E

25 Operator control 4.1 Creating applications from the command line Strip tool The strip tool reduces.exe files and.386 files. NOTICE The strip tool may only be used for executable programs in the release configuration. With rm-strip <file.exe> --strip-unneeded the symbols are removed. More information on strip.exe is available under <rmos_dir>\doc\binutil.pdf. Call in the make file: all: $(ExeFile) compress compress: rm-strip $(ExeFile) --strip-unneeded Defining the stack size The standard stack size of RMOS3 applications is 0x1000 bytes. This is also the minimum settable value. This value is not sufficient for some applications. You can specify the stack size in the source code file main.cpp or you can set the environment variable ElfStack on your target system. Defining the stack size in the source code Enter the following lines in the given sequence in the source code file that contains the main() routine: #define _RMOSLDR_FOR_GNU_STACKSIZE 0x4000 /*stack size in bytes*/ #include "rmos_stack.h" NOTICE You must set #define before #include. You may integrate the header file only once. NOTICE If the stack size is too small, RMOS3 issues the Page Fault error message when processing the application and stops the program. Programming and Operating Manual, 07/2009, A5E

26 Operator control 4.1 Creating applications from the command line Defining the stack size with the environment variable You can also increase the stack size (in bytes) using the ElfStack environment variable with the following command line command on your target system: set ElfStack=<stacksize> NOTICE If you specify the stack size in the source code and in the environment variable, the value specified in the source code is used. Example set ElfStack= Programming and Operating Manual, 07/2009, A5E

27 Operator control 4.1 Creating applications from the command line make NOTICE If you want to use the make GNU tool from the command line to generate your application, you must first call the MSYS3_0.BAT batch in the same DOS box that expands the path variable with the necessary settings for MSYS/MinGW. This batch is saved during installation of RMOS3-GNU V3.0 in the Windows system directory and can be called immediately. Calling make The GNU tool make is used to generate applications. Use the following syntax to call the make tool from the command line: make <Parameter list> The following parameters can be used for generating the RMOS3 applications: Parameters Description -f <new_makefile> The <new makefile> file is used as a generation file instead of the makefile file. NOTICE When creating or copying make files, ensure that the file name new_makefile does not include any uppercase letters and spaces. The syntax of the make tool of the GNU tool chain is different to that of the make files of other make tools (for example, nmake by Microsoft). Note The manually created make files of the examples always create *.386 files as output files. Automake files, which are generated by the Eclipse IDE, create *.exe files. Both can be executed under RMOS3 as of version Information on the make tool A more detailed description of the make tool and the make files can be found in the document <rmos_dir>\doc\make.pdf. Programming and Operating Manual, 07/2009, A5E

28 Operator control 4.1 Creating applications from the command line Example make file for a C application under RMOS3: The make file makefile has the following basic structure: # Compiler and linker parameters for creating the # release version: # GCC_FLAGS = -Wall -O3 -I$(RMOS_HOME)/inc -fno-common # LD_FLAGS = -nodefaultlibs -Xlinker --emit-relocs # Compiler and linker parameters for creating the # debug version: GCC_FLAGS = -Wall -ggdb -I$(RMOS_HOME)/inc -fno-common LD_FLAGS = -nodefaultlibs -Xlinker -r -Xlinker --script -Xlinker elf_i386_rmos.xr LD = rm-gcc.exe GCC = rm-gcc.exe ExeFile = <exefile>.386 ObjFiles = <file1>.o <file2>.o # Following libraries will be integrated: # C++ library libstdc++.a # C library libgcc.a # FastTimer Tick library libfastg.a # CLI library libclig.a # Crun library libcrig.a # HLI library libhlig.a RuntimeFile = -L $(RMOS_HOME)/lib/gnu -lgcc -lfastg -lclig -lcrig -lhlig # rule for release generation # all: $(ExeFile) compress # rule for debug generation all: $(ExeFile) compress: rm-strip $(ExeFile) --strip-unneeded $(ExeFile): <file1>.o: <file2>.o: clean: $(ObjFiles) $(LD) $(LD_FLAGS) -o $(ExeFile) $(ObjFiles) $(RuntimeFile) <file1>.c $(GCC) $(GCC_FLAGS) -c -o <file1>.o <file1>.c <file2>.c $(GCC) $(GCC_FLAGS) -c -o <file2>.o <file2>.c rm -f $(wildcard *.386) rm -f $(wildcard *.o) 26 Programming and Operating Manual, 07/2009, A5E

29 Operator control 4.1 Creating applications from the command line Example make file for a C++ application under RMOS3: A make file for a C++ application has the following structure: # Compiler and linker parameters for creating the # release version: # GCC_PLUS_FLAGS = -Wall -O3 -I$(RMOS_HOME)/inc -fno-common # LD_FLAGS = -nodefaultlibs -Xlinker --emit-relocs # Compiler and linker parameters for creating the # debug version: GCC_PLUS_FLAGS = -Wall -ggdb -I$(RMOS_HOME)/inc -fno-common LD_FLAGS = -nodefaultlibs -Xlinker -r -Xlinker --script -Xlinker elf_i386_rmos.xr LD = rm-g++.exe GCC_PLUS = rm-g++.exe ExeFile = <exefile>.386 ObjFiles = <file1>.o <file2>.o # Following libraries will be integrated: # C++ library libstdc++.a # C library libgcc.a # FastTimer Tick library libfastg.a # CLI library libclig.a # Crun library libcrig.a # HLI library libhlig.a RuntimeFile = -L $(RMOS_HOME)/lib/gnu -lstdc++ -lgcc -lfastg -lclig -lcrig -lhlig # Compile and link source file # rule for release generation # all: $(ExeFile) compress # rule for debug generation all: $(ExeFile) compress: rm-strip $(ExeFile) --strip-unneeded $(ExeFile): <file1>.o: <file2>.o: $(ObjFiles) $(LD) $(LD_FLAGS) -o $(ExeFile) $(ObjFiles) $(RuntimeFile) <file1>.cc $(GCC_PLUS) $(GCC_PLUS_FLAGS) -o <file1>.o -c <file1>.cc <file2>.cc $(GCC_PLUS) $(GCC_PLUS_FLAGS) -o <file2>.o -c <file2>.cc clean: rm -f $(wildcard *.386) rm -f $(wildcard *.o) Programming and Operating Manual, 07/2009, A5E

30 Operator control 4.2 Creating applications under the Eclipse IDE 4.2 Creating applications under the Eclipse IDE Sequence In order to be able to create applications under the Eclipse IDE and the GNU tool chain for RMOS3, the steps described in the following sections must be followed. Step Description 1 Starting the Eclipse IDE 2 Changing to C/C++ view 3 Setting up the workbench 4 Creating or importing an application 5 Transferring to the target system 6 Starting the application on the target system Starting the Eclipse IDE Call You have the following options to start the Eclipse IDE on the development system: Using the Start menu Using the link in the user interface Using the Windows Explorer with a double-click on ECL3_4.BAT in <eclipse_dir> Using the instruction <eclipse_dir>\ecl3_4.bat in the command line Call parameter for language switch The Eclipse IDE provides a -nl <Language> call parameter to display help pages in the selected language. Example: eclipse.exe -nl fr_fr The help pages in this example are displayed in French if they are available in this language. If there are no pages in French, the default pages in German are displayed. 28 Programming and Operating Manual, 07/2009, A5E

31 Operator control 4.2 Creating applications under the Eclipse IDE Workspace A workspace is required to start the Eclipse IDE. A workspace is a directory in which general settings for the Eclipse IDE and references to integrated programs are saved. The Eclipse IDE is started with a dialog that inquires about the desired workspace directory (Figure Choosing the workspace directory). If you do not stipulate a directory, under the current directory the workspace directory workspace will be created and used if necessary. Figure 4-2 Choosing the workspace directory When calling the Eclipse IDE from the command line, with the additional parameter -data <workspace_dir> a special workspace directory can be stipulated. When calling from the Windows Explorer, the directory <eclipse_dir> is used as the workspace directory, if no workspace directory has been chosen. NOTICE When stipulating the workspace directory, ensure the drive and the directory names are spelt precisely (uppercase or lowercase letters), otherwise the debugging in the Eclipse IDE will not function properly. The description in the Windows Explorer is decisive. NOTICE The name of the workspaces may not include any spaces. Programming and Operating Manual, 07/2009, A5E

32 Operator control 4.2 Creating applications under the Eclipse IDE Welcome screen When you first start the Eclipse IDE, a welcome screen appears which offers tutorials, examples, and an overview of the latest developments. To get to the Eclipse IDE Workbench, right-click the Workbench symbol 1 (Figure Welcome screen). Figure 4-3 Welcome screen 30 Programming and Operating Manual, 07/2009, A5E

33 Operator control 4.2 Creating applications under the Eclipse IDE C/C++ view Activating You get to the C/C++ view once you close the welcome screen. Checking the activation When the C/C++ view is activated, the icon marked in the following illustration (Figure Eclipse IDE window of the CDT plug-in) must appear in the Eclipse IDE user interface. Figure 4-4 Eclipse IDE window of the CDT plug-in Setting up the workbench Purpose By setting up the workbench you can ensure that changes to the source code are saved and adopted by the executing program. Setup In default the workbench is set up in such a way that a compiling event is automatically triggered with each save. We recommended that you deactivate this setting. To do this, deactivate the Build automatically option with the menu command Window Preferences General Workspace. The Save automatically before build option should then be activated. Programming and Operating Manual, 07/2009, A5E

34 Operator control 4.2 Creating applications under the Eclipse IDE Creating an application The individual steps necessary for creating an application are listed in section Transferring the application to the target system. The individual steps are again explained in section Example - creating an application. Creating No. Step Description 1 Creating a project - Menu File New Project 2 Create program file - Select project nodes - Menu New File 3 Enter program - C, C++, Assembler 4 Set compiler parameters - Select project nodes - Menu Properties - Selection field C/C++ Build - Selection field Settings Tool Settings - Menu rm-gcc C compiler 5 Set linker parameters - Selection field Settings Tool Settings - Menu rm-gcc C linker 6 Configure strip tool - Select project nodes - Menu Properties - Selection field Builders New button 7 Compiling the project - Menu Project Build Project See also Example of application generation (Page 93) Transfer the application to the target system (Page 34) Importing example projects Example projects Examples are created during the installation of RMOS3-GNU V3.0. These can be imported into the Eclipse IDE. The import is illustrated in the following by means of the supplied example busy. 32 Programming and Operating Manual, 07/2009, A5E

35 Operator control 4.2 Creating applications under the Eclipse IDE Carrying out the import In order to be able to create applications under the Eclipse IDE and the GNU tool chain for RMOS3, the steps described in the following sections must be followed. Step Description 1 Select menu command File Import. 2 In the Import dialog box, select the entry General Existing Projects into Workspace. 3 Press the Next button. 4 With the Browse button 1 (Figure Eclipse IDE dialog for importing the busy example), select the project directory. 5 Select Copy projects into workspace if you want to copy the example into the current workspace. Otherwise, the example in the RMOS3 tree is used. Figure 4-5 Eclipse IDE dialog for importing the busy example Step Description 6 Press the Finish button 2 (Figure Eclipse IDE dialog for importing the busy example). 7 The entire busy project is displayed in the Project Explorer. Programming and Operating Manual, 07/2009, A5E

36 Operator control 4.2 Creating applications under the Eclipse IDE Figure 4-6 Imported busy project in the Eclipse IDE You can import the complete example tree at once. The procedure is as described above. Select the <rmos_dir>\examples folder as root directory. All GNU projects in the folder are displayed and can be imported Transfer the application to the target system Transmission The application can be transferred to the target system via the FTP, the remote launch plugin, the FTP plug-in or via diskette. The FTP daemon must be started on the target system in order to transfer via FTP or remote launch. With diskette When transmitting the executable file by diskette ensure that prior to the copying command a dismount and then a mount command has taken place. With FTP When transmitting the executable file with FTP ensure that this takes place in binary mode (bin command in FTP client). With FTP plug-in The transfer can also take place in the Eclipse IDE with the supplied FTP plug-in (refer to section Downloading with FTP). 34 Programming and Operating Manual, 07/2009, A5E

37 Operator control 4.2 Creating applications under the Eclipse IDE With remote launch plug-in The application can also be transferred with the Remote Launcher. The application is then executed automatically on the target system or the debugger is started. (see section Using the Remote Launcher). See also Downloading with FTP (Page 41) Using the Remote Launcher (Page 42) Project type Executable (GNU on RMOS) In order to facilitate creating an application, there is now a new Executable (GNU on RMOS) project type in addition to the standard CDT project types (for example, Executable). If you use this project type when setting up a project, the most important compiler and linker options are preset. This project type offers the debug, release and simulation configurations (see section RMOS3 simulation on the development PC). Release configuration With the release configuration, an executable file for the RMOS3 target system is created. The compiler optimizations are activated. The RMOS Elf parser is used as a binary parser. Debug configuration With the debug configuration, an executable program in the GDB server is created for the RMOS3 target system. This program can then be debugged via remote debugging on the target system. The RMOS Elf parser is used as a binary parser. NOTICE "Unresolved Externals" are not detected when linking in the debug configuration. The error results during loading on the target system. Use the release configuration to recognize "Unresolved Externals" during linking. Simulation configuration With the simulation configuration, an executable program under Windows is created for the development system. The PE Windows parser is used as a binary parser. The library librmwin32.a is pre-set and the define RMOS_SIMULATION is set. In order to be able to execute the program, the RMWIN32.dll must be in the search path (PATH variable) of the computer. It is usually located under <rmos_dir>\simulation\bin. Programming and Operating Manual, 07/2009, A5E

38 Operator control 4.2 Creating applications under the Eclipse IDE Selecting the project type Executable (GNU on RMOS) In order to use the Executable (GNU on RMOS) project type, select the command C under File New Project and here the sub-command C Project. Click Next to go to the next dialog. After entering a suitable name for the project, select Executable (GNU on RMOS) as the project type 1 (Figure Setting up a project with the type Executable (GNU on RMOS ). Click Next to go to the next dialog. Click Finish. Figure 4-7 Setting up a project with the type Executable (GNU on RMOS) After you have written a new program and compiled it in all three configurations, the navigator tree appears as follows: 36 Programming and Operating Manual, 07/2009, A5E

39 Operator control 4.2 Creating applications under the Eclipse IDE Figure 4-8 Navigator tree of an Executable (GNU on RMOS) project See also RMOS3 simulation on the development PC (Page 66) Project type Static Library (GNU on RMOS) In order to facilitate creating an application, there is the Static Library (GNU on RMOS) project type in addition to the standard CDT project types (for example, Executable). You can use this project type to create libraries. These can then be connected statically to RMOS3 applications. If you use this project type when setting up a project, the most important compiler and linker options are preset. This project type offers the debug, release, and simulation configurations for creating a static library. Release configuration With the release configuration, a static library is created for the RMOS3 target system. The compiler optimizations are activated. Debug configuration With the debug configuration, a static library is created for the RMOS3 target system. The created library contains debug information. This means you can debug the library functions contained in the library. Simulation configuration With the simulation configuration, a static library is created for the Windows target system. The created library contains debug information. This means you can debug the library functions contained in the library. This configuration should only be used for test purposes (see section RMOS3 simulation on the development PC). Programming and Operating Manual, 07/2009, A5E

40 Operator control 4.2 Creating applications under the Eclipse IDE Selecting the project type Static Library (GNU on RMOS) In order to use the Static Library (GNU on RMOS) project type, select the command C under File New Project and here the sub-command C Project. Click Next to go to the next dialog. After entering a suitable name for the library, select Static Library (GNU on RMOS) as the project type 1 (Figure Setting up a project with the type Static Library (GNU on RMOS)). Click Next to go to the next dialog. Click Finish. Figure 4-9 Setting up a project with the type Static Library (GNU on RMOS) See also RMOS3 simulation on the development PC (Page 66) Code completion The Eclipse IDE offers code completion for all supported functions. 38 Programming and Operating Manual, 07/2009, A5E

41 Operator control 4.2 Creating applications under the Eclipse IDE Configuration 1. You can select which sources are used for code completion, for example: The supplied help plug-ins Selection Template Proposals 1 (Figure Configuration of code completion) The header files Selection Parsing-based Proposals 2 (Figure Configuration of code completion) To select, use the menu command Window Preferences C/C++ Editor Content Assist Advanced. We recommend using Template Proposals and Parsing-based Proposals. Figure 4-10 Configuration of code completion Programming and Operating Manual, 07/2009, A5E

42 Operator control 4.2 Creating applications under the Eclipse IDE 2. In order to use code completion, enter the first letters of the desired function and then press <CTRL+Space>. A window opens with a selection list of all functions that start with this letter and which are included in the Default content assist list (Figure Using code completion). Figure 4-11 Using the code completion 3. If you press <CTRL + Space> again, the functions that are included in the additional selection list in the top entry are listed. By pressing <CTRL + Space> repeatedly, the selection list is interconnected successively. 4. If you select a function, it is inserted at the current cursor position. The cursor is at the first parameter or, with void functions, behind the closed bracket. For functions with several parameters, you can navigate from parameter to parameter with the <TAB> key. 40 Programming and Operating Manual, 07/2009, A5E

43 Operator control 4.2 Creating applications under the Eclipse IDE Downloading with FTP A plug-in is integrated in the Eclipse IDE to transfer programs created from the Eclipse IDE to the RMOS3 target system via FTP. Procedure Select the required profile in the project tree. Select the menu command Run External Tools External Tools Configurations... The dialog window External Tools Configurations opens. It includes the configuration category "FTP Beamer". By double-click on the category, you can create new configurations containing the connection data for the respective target system. Figure 4-12 Entering connection data You only have to enter the connection data (host name, user name, password and target directory) 1 (Figure Entering connection data) the first time you configure a connection and confirmed it with the Apply button 2 (Figure Entering connection data). These settings are retained. Programming and Operating Manual, 07/2009, A5E

44 Operator control 4.2 Creating applications under the Eclipse IDE The starting basis in each case is the project selected in the project tree or the source text editor that is currently being used for editing purposes. The application is transferred in the configuration that is currently selected. If the Debug configuration is currently selected, the debug application is transferred to the target system. The file is used as an application that is specified under Project Properties C/C++ Build Settings Build Artifact. You start the transfer of the application by pressing the Run button. Note In contrast to RMOS3-GNU V2.1, the application is not compiled again before it is transmitted due reasons of performance Using the Remote Launcher You use the remote launch configuration to transfer a generated application to the target system and to launch it there. Editions of the program are then displayed in the console that is integrated into the Eclipse IDE. You need a run configuration for this. You can also use the Remote Launcher to debug an application on the target system without having to transfer it manually to the target system and then start the debug server. You need a debug configuration for this. The following pages include a description of how you create a remote launch configuration for an existing project. Note To use the Remote Launcher, the FTP and the TELNET daemon must be started on the target system. You must enter the user in the PASSWD and TPASSWD file. Creating a run configuration To create a new run configuration, open the menu command Run Run Configurations Programming and Operating Manual, 07/2009, A5E

45 Operator control 4.2 Creating applications under the Eclipse IDE Creating a new debug configuration To create a new debug configuration, open the menu command Run Debug Configurations... (Figure Opening the Debug Configurations window). Figure 4-13 Opening the Debug Configurations window You now see the dialog for managing your remote launch configuration (debug or run). Right-click Remote Launch and create a new configuration with New (Figure Creating a new remote launch configuration). Figure 4-14 Creating a remote launch configuration Programming and Operating Manual, 07/2009, A5E

46 Operator control 4.2 Creating applications under the Eclipse IDE Basic settings of the configuration Enter a suitable name for your configuration. Because the configuration is logically a part of the project, it may make sense to enter the project name here 1 (Figure Project settings). Check to see if your current project is entered in the Project field 2 (Figure Project settings). The most important part is selecting the correct application. If you want to not only execute the application on the target system later but also debug it, you must enter the debug version of your application here. For example, "Debug/MyGnu.exe" 3 (Figure Project settings). You may also enter the debug or release version here. Figure 4-15 Project settings 44 Programming and Operating Manual, 07/2009, A5E

47 Operator control 4.2 Creating applications under the Eclipse IDE Specification of call parameters and environment variables If you want to add a call parameter to your application, you can enter it on the Arguments page 1 (Figure Remote environment settings). If your application uses certain environment variables, you can enter these as customary for RMOS3 in the clistart.bat file. These environment variables are then available for all consoles. If you want to use environment variables that are only valid during the remote launch process, you can enter them on the Environment page 2 (Figure Remote environment settings). Figure 4-16 Remote environment settings Programming and Operating Manual, 07/2009, A5E

48 Operator control 4.2 Creating applications under the Eclipse IDE Specifications for the debugger The following settings are only available if you have created a debug configuration. The "RMOS Debugger" is selected on the Debugger page 1 (Figure Debugger settings). rm-gdb is entered in the GDB debugger input field 2 (Figure Debugger settings). The settings on this page should not be changed. Figure 4-17 Debugger settings 46 Programming and Operating Manual, 07/2009, A5E

49 Operator control 4.2 Creating applications under the Eclipse IDE Specifications for the connection To specify your target system, open the page Remote Target (see 1 in the figure Target settings). Host is the network name or the IP address of the target system, for example, " " 2 (Figure Target settings). User Name is the name of the user who is trying to establish a connection, for example, root 3 (Figure Target settings). Password is the password of the user who is trying to establish a connection. Target Directory is the directory on the target system in which the application is copied during the remote launch process, for example, C:\RM3TMP 4 (Figure Target settings). On this page you can specify if you want to debug or execute your application on the Privilege Level 0 (PL0) 5 (Figure Target settings) or Privilege Level 3 (PL3) 6 (Figure Target settings) (default). Figure 4-18 Target settings Programming and Operating Manual, 07/2009, A5E

50 Operator control 4.2 Creating applications under the Eclipse IDE Note The user must be authorized to establish an FTP as well as a TELNET connection. You may have to adapt the PASSWD and TPASSWD files in the C:\NET folder of your target system. User name and password must be identical in both files. See "Programming manual RMOS3-TCP/IP V2.1" section The "PASSWD" file and The "TPASSWD" file. Saving and starting the configuration The Common page 1 (Figure Additional settings) includes additional setting options that you do not have to change. For support, go to the Eclipse IDE help. To save the configuration, click the Apply button 2 (Figure Additional settings). To start the configuration, click the Run or Debug button 3 (Figure Additional settings). Figure 4-19 Additional settings 48 Programming and Operating Manual, 07/2009, A5E

51 Operator control 4.2 Creating applications under the Eclipse IDE Executing the Remote Launcher To start the Remote Launcher, click the Debug or Run button and select your configuration. Figure 4-20 Starting the Remote Launcher Programming and Operating Manual, 07/2009, A5E

52 Operator control 4.2 Creating applications under the Eclipse IDE RMOS3 help A help function is available in German for all supported RMOS3 calls. You open the Help Explorer with the menu command Help Help Contents. Here you have to select the RMOS online help 1 (Figure RMOS online help). Figure 4-21 RMOS online help 50 Programming and Operating Manual, 07/2009, A5E

53 Operator control 4.2 Creating applications under the Eclipse IDE You can also open the help pages using the "F1" key. To do this, position the cursor on the function for which you would like to show a help page, and then press "F1". A selection menu with the existing help pages appears. Figure 4-22 Selection window for help Then select <Call> 1 (Figure Selection window for help). The dynamic help window opens and the help page for the respective function is displayed. Programming and Operating Manual, 07/2009, A5E

54 Operator control 4.2 Creating applications under the Eclipse IDE Figure 4-23 Dynamic help If you prefer to open the help page in the Help Explorer for reasons of clarity, click the Show in external window button 1 (see Figure Dynamic help). 52 Programming and Operating Manual, 07/2009, A5E

55 Operator control 4.2 Creating applications under the Eclipse IDE The respective function is then displayed in the Help Explorer (see Figure Help window for a call). Figure 4-24 Help window for a call Note If you point your mouse cursor on a function call in the source code, a tooltip is displayed. The sequence of the call parameters is reversed for RMOS API functions. Programming and Operating Manual, 07/2009, A5E

56 Operator control 4.2 Creating applications under the Eclipse IDE 54 Programming and Operating Manual, 07/2009, A5E

57 Testing an RMOS3 application 5 Possibilities RMOS3 applications can be tested with both command line with the GDB client as well as graphically with the Eclipse IDE. Note For these two test types, the application (for example, with the FTP plug-in) needs to be transferred to the target system and the GDB server must be started on the target system. This happens automatically when you use the Remote Launcher. The GDB client (rm-gdb.exe) and the Eclipse IDE debugger can only communicate with the GDB server of the RMOS3 target system via TCP/IP. Applications that are created with the RMOS3 simulation can be locally debugged on the development system with the gdb.exe (see section Debugging). See also Debugging (Page 76) Using the Remote Launcher (Page 42) Programming and Operating Manual, 07/2009, A5E

58 Testing an RMOS3 application 5.1 Testing on the target system 5.1 Testing on the target system NOTICE The GDB server under RMOS3 exclusively supports the remote debugging via TCP/IP. If an IP address is given when the GDB server is started, make sure to use the IP address that is specified in the RMOS.INI file on the target system. The GDB server does not check the concordance of these two addresses. NOTICE The GDB server does not support debugging in the interrupt handlers. The GDB server supports a maximum of 256 tasks. Only one breakpoint context can be active. You can switch between several breakpoints. When the GDB server reaches a breakpoint, all tasks that are part of the application are stopped. Single steps are only possible in a breakpoint context. Watchpoints are not supported. Trace points are not supported. If the main task is in the ACTIVE or READY state, it is stopped in the "Attach mode" by the GDB server and can be continued with the respective debug commands. If the main task is in the BLOCKED state (for example, with "RmPauseTask ), however, it continues to run as soon as its task state changes. No Exit handler is called when you cancel an Eclipse debugger session in the user program. NOTICE The versions of GDB server and rm-gdb are dependent on each other. The use of versions that do not match results in an error message. Note Local static constant variables (except strings) are not displayed in the variable window and in the Expressions window because the compiler optimizes them away. Global static variables can be displayed in the Expressions window. Global static constant strings are not displayed in the Expressions window. 56 Programming and Operating Manual, 07/2009, A5E

59 Testing an RMOS3 application 5.1 Testing on the target system Testing from the command line Starting the GDB server Starting The GDB server is started on the target system with the following call: gdbsrvgn [-attach=<task-id>[:childtask-id]] [-port=<ip-address>:<port number>] <Program name> [<Program arguments>] Start parameters As the <IP address>:<port number> you use the IP address and the port of the target system under which the GDB server can be reached from the development system. For <IP address>:<port number> there is a default: The own IP address of the computer upon which the GDB server is being launched is used as an IP address is used as the port number. Note The ports 0 to 1024 are already reserved as standard ports for the network services and should therefore not be used when calling the GDB server. That way, the following call is also possible: gdbsrvgn <program name> [<program arguments>] It is possible to debug already running applications with the option -attach=<task- ID>[:<ChildTask-ID>]. <Task ID> must be the task ID of the already running main task. As an option, the task ID of a child task can be specified with the parameter <ChildTask-ID> in order to directly link with this. Enter the values in hexadecimal form. Example: C:\>gdbsrvgn attach=0x4e:0x52 testapp.exe arg1 It is also possible to link with an application that is running on an exception. After linking with the GDB, the line in the source text is displayed in which the exception has occurred. NOTICE If the GDB server is canceled with "CTRL-C", the system resources of the application (for example, semaphores) remain busy. This problem can be remedied by using the C library function "atexit() (see RMOS3 user manual). Programming and Operating Manual, 07/2009, A5E

60 Testing an RMOS3 application 5.1 Testing on the target system Testing with the GDB client With the aid of the GDB client, debug commands can be sent from the development system via the command line to the GDB server running on the target system. GDB server messages After launching the GDB server from the command line of the target system, this waits for a link connection from the GDB client. The following message appears: RMOS3 Gnu-Elf DebugServer <Version> derived from Free Software Foundation, Inc., Copyright <year> using default connection localhost:8200 start loading <Program name>......done;: pid = <pid> GdbServer wait for connection... If no TCP/IP stack is launched on the target system, the following error message appears: Can't open socket: Operation not supported. If the application is not created as a debug version, the following error message appears: Error : debug target is not linked relocatable: try '-r' with the linker options Error : can't create target <Program name> Starting the GDB client The GDB client is launched with the command rm-gdb <Program name> on the console of the development system. The program name can end with.exe or.386. The following message appears: GNU gdb <Version> (adjusted for RMOS by Siemens AG, I IA SE <year>) Copyright <year> Free Software Foundation, Inc. License GPLv3+: GNU GPL version 3 or later < This is free software: you are free to change and redistribute it. There is NO WARRANTY, to the extent permitted by law. Type "show copying" and "show warranty" for details. This GDB was configured as "--host=i686-pc-mingw32 --target=i586-rmos-elf"... (gdb) After the command line appears with the prompt (gdb), debug commands can be entered. 58 Programming and Operating Manual, 07/2009, A5E

61 Testing an RMOS3 application 5.1 Testing on the target system Starting the test With the debug command target remote <IP-Address:Port number> a TCP/IP connection is created with the GDB server of the target system. The following message appears on the development system: Remote debugging using <IP-Address:Port number> <Address> in _start () The following message appears on the target system : Remote debugging with host <Host-IP-Address > Setting breakpoints First of all a breakpoint must be set in the main function with the instruction break main which is acknowledged on the development system with the following message: Breakpoint 1 at <Address>: file <File>, line <Line> The main method can be started with the instruction cont which is then acknowledged with the following message: Continuing. Breakpoint 1, main () at <File>:<Line> <Line> int i=0; Now the application can be tested. Programming and Operating Manual, 07/2009, A5E

62 Testing an RMOS3 application 5.1 Testing on the target system Command line parameters A more detailed description of the command line parameters of the GDB client can be found on the development system under <rmos_dir>\doc\gdb.pdf. A more detailed description of the GDB command can be issued with the instruction help. Brief instructions can be found on the development system under <rmos_dir>\doc\gdb_quick.pdf Testing with the Eclipse IDE debugger The test run with the Eclipse IDE debugger is displayed using the example application MyGnu. Note The creation of the example application "MyGnu" is described in the section Example application creation. Before the example application MyGnu can be tested with the Eclipse IDE debugger, special project settings must be carried out prior to launching the debugger. These settings apply only to remote debugging. For debugging with the RMOS3 simulation, refer to section Debugging. To ensure that the timeout periods between Eclipse IDE debugger and the GDB server are also sufficient for debugging very large files, proceed as follows: 1. Select the menu command Window Preferences. 2. Select the node C/C++ Debug GDB MI in the selection. 3. Set the following values: Variable Value Debugger Timeout Launch Timeout See also Using the Remote Launcher (Page 42) Usage with the Eclipse IDE (Page 75) Debugging (Page 76) Example of application generation (Page 93) 60 Programming and Operating Manual, 07/2009, A5E

63 Testing an RMOS3 application 5.1 Testing on the target system Choosing the application to be tested Select the C/C++ Local Application entry in the left selection list with the menu command Run Debug Configurations and the Debug Configurations dialog, and confirm by clicking the New button. Then the already pre-configured setting possibilities appear in the right part of the dialog. In the Main tab of the Debug dialog, enter the name of the program you want to execute along with the relative path name 1 (Figure Setting application to be executed). Figure 5-1 Setting the application to be executed Programming and Operating Manual, 07/2009, A5E

64 Testing an RMOS3 application 5.1 Testing on the target system Setting up the working directory Deactivate the Use default entry in the Arguments tab 1 (Figure Setting up the working directory). This step automatically activates the entry Workspace 2 (Figure Setting up the working directory). Figure 5-2 Setting up the working directory 62 Programming and Operating Manual, 07/2009, A5E

65 Testing an RMOS3 application 5.1 Testing on the target system Choosing the debugger and setting up the connection data Select the gdbserver Debugger entry in the Debugger tab in the Debugger selection 1 (Figure Configuration of the debug server). Enter rm-gdb as debugger under RMOS3 in the Main tab. You can keep the other settings in the Main tab. Figure 5-3 Configuration of the debug server Select TCP as the type of Connection 1 (Figure Configuration of the IP address of the debug server). Programming and Operating Manual, 07/2009, A5E

66 Testing an RMOS3 application 5.1 Testing on the target system In the input fields Host name or IP address and Port number 2 (Figure Configuration of the IP address of the debug server), enter the IP address and the port of the target system under which the GDB server can be reached by the development system. The default port 8200 has already been set. Figure 5-4 Configuration of the IP address of the debug server Starting the test You create the connection to the GDB server on the target system with the menu command Run Debug Configurations and by clicking the Debug button in the Debug Configurations dialog. The application is launched in the GDB server on the target system and stopped at the function main(). The Eclipse IDE automatically changes to the debug view. 64 Programming and Operating Manual, 07/2009, A5E

67 Testing an RMOS3 application 5.1 Testing on the target system Debugger interface Figure 5-5 Eclipse IDE debugger The debug icon 1 (Figure Eclipse IDE debugger) appears in the debug view of the Eclipse IDE. In this view, you can do the following with the aid of the toolbar in the Debug window 2 (Figure Eclipse IDE debugger): Execute a single instruction Select a function Stop the program Restart the program Various debugger functions are offered in the 3 window (Figure Eclipse IDE debugger) to the right of the Debug window, whereby the following functions are supported under RMOS3: Viewing and changing variables (Variables) Activating, deactivating breakpoints as well as setting conditions for breakpoints (Breakpoints) Evaluating expressions (Expressions) Open with Window -> Show View -> Expressions The Memory view is available in the lower window 4 (Figure Eclipse IDE debugger). It is used for viewing and changing register values (Registers). Programming and Operating Manual, 07/2009, A5E

68 Testing an RMOS3 application 5.2 RMOS3 simulation on the development PC NOTICE You cannot use the Signals view. NOTICE A single step across an "empty" while loop or a while loop with an instruction in the same line results in a permanent single step. It can no longer be stopped. Example: while(flag); or while(flag) {dummy = 5;} 5.2 RMOS3 simulation on the development PC Objective of the RMOS3 simulation The RMOS3 simulation is used to pre-test RMOS3 programs on the development PC under Windows with the Eclipse IDE Restrictions and limits The following general restrictions must be observed: Some calls are not supported at all or only to a limited extent. (See section Functions not supported or section Functions supported to a limited extent). BSP calls are not supported (unresolved symbols). Due to different runtime environments, there may be incompatibilities with the following calls under RMOS3: open(), read(), write(), close(), chmod(), search(), access(), chdir(), fileno(), getcwd(), mkdir(), rmdir(), sleep() unlink(). The exact description of the calls is available in the documentation for the respective operating system. On account of the differing runtime environment, incompatibilities can arise with the C++ functionality. 66 Programming and Operating Manual, 07/2009, A5E

69 Testing an RMOS3 application 5.2 RMOS3 simulation on the development PC The nucleus calls have the following restrictions: The chronological execution characteristic differs under the simulation and under RMOS3. The priority characteristic with the tasks is completely different. The priority mode (for example, RM_TCD_PRI, RM_INCPRI) may result in a different execution of tasks. The scheduler characteristics differ. There is no preemptive task scheduling and no round robin functionality. With the recipient, mails are dealt with according to the FIFO principle - independently from the priority. If two tasks of differing priority are waiting at the same mailbox and the mail arrives, the mail is not passed on to the higher-priority task, but to the task that is waiting first of all at the mailbox. The automatic elevation in priority with semaphores is not supported. There is no TCB administration block with the tasks. The status of the task RM_READY and RM_ACTIVE are not different. In this case there is only the status RM_ACTIVE. With the status RM_BLOCKED there is no further distinction. Troubleshooting differs slightly with the calls, which means other error codes could be registered with the simulation in error situations than those under RMOS3. NOTICE With the simulation no Windows applications can be generated that can communicate with other applications across the process borders of Windows and beyond. See also Unsupported functions (Page 71) Restricted supported functions (Page 70) Quantity framework The following quantity framework applies for the simulation: Resource Simulation RMOS3 (for example, V3.30) Semaphores Memory pools 1 8 Mail boxes Event flag groups Tasks Programming and Operating Manual, 07/2009, A5E

70 Testing an RMOS3 application 5.2 RMOS3 simulation on the development PC Priority behavior The aim is to reproduce the priority characteristic of RMOS3 as well as possible under Windows. Windows has 7 different priorities. The tasks can be assigned specific priorities, but there is no guarantee that these priorities will be used. In the simulation only the priority class NORMAL_PRIORITY_CLASS is used. Within this priority class there are 7 different priorities: THREAD_PRIORITY_IDLE THREAD_PRIORITY_LOWEST THREAD_PRIORITY_BELOW_NORMAL THREAD_PRIORITY_NORMAL THREAD_PRIORITY_ABOVE_NORMAL THREAD_PRIORITY_HIGHEST THREAD_PRIORITY_TIME_CRITICAL In doing so, the THREAD_PRIORITY_IDLE is the lowest and the THREAD_PRIORITY_TIME_CRITICAL is the highest priority. The RMOS3 priority is divided by 37. This value is used as the Windows priority. That results in the following priority mapping: RMOS3 priority Window priority THREAD_PRIORITY_IDLE THREAD_PRIORITY_LOWEST THREAD_PRIORITY_BELOW_NORMAL THREAD_PRIORITY_NORMAL THREAD_PRIORITY_ABOVE_NORMAL THREAD_PRIORITY_HIGHEST THREAD_PRIORITY_TIME_CRITICAL As there is no TCB for a task in the simulation, the current priority of a task is saved in the TCD element "Inherent Priority". The priority mode RM_INCPRI leads to an increase in the Windows priority by one level, the priority mode RM_DECPRI lowers the Windows priority by one level. The main thread has the RMOS3 priority 129, which corresponds to the Windows priority THREAD_PRIORITY_NORMAL. 68 Programming and Operating Manual, 07/2009, A5E

71 Testing an RMOS3 application 5.2 RMOS3 simulation on the development PC Existing functions Supported functions The following RMOS3 calls can be used in simulation mode: RmBindTask RmCatalog RmCreateFlagGrp RmCreat box RmCreateBinSemaphore RmCreateMessageQueue RmCreateTask RmCreateTaskEx RmDeleteBinSemaphore RmDeleteFlagGrp RmDelet box RmDeleteMessageQueue RmDeleteTask RmEndTask RmFree RmGetBinSemaphore RmGetBindTaskInfo RmGetEntry RmGetFlag RmGetName RmGetSize RmGetTaskPriority RmGetStatusMessageQueue RmKillTask RmList RmPauseTask RmQueueStartTask RmReadMessage RmReceiv RmReleaseBinSemaphore Programming and Operating Manual, 07/2009, A5E

72 Testing an RMOS3 application 5.2 RMOS3 simulation on the development PC RmResetFlag RmResetLocalFlag RmResumeTask RmSendMailDelayed RmSetFlag RmSetFlagDelayed RmSetLocalFlag RmSetMailboxSize RmSetMessageQueueSize RmSetTaskPriority RmStartTask RmUncatalog gettimestamp Restricted supported functions The following RMOS3 calls can be used with restrictions in simulation mode: RMOS3 call RmActivateTask RmAlloc RmCreateChildTask RmDecode RmDisableScheduler RmEnableScheduler RmExclude RmFlatToSegAddress RmFreeAll RmGetAbsTime Restrictions Launches the given task (must be dormant) Parameter TimeOutValue is not supported, a memory assignment is not expected Calls the RmCreateTask Dummy, returns only RM_OK Dummy, returns only RM_OK Dummy, returns only RM_OK Dummy, returns only RM_OK Always returns 0x68 as the selector Dummy, only returns RM_OK, TaskID is checked Only 32-bit value, therefore overflow after 49.7 days RmGetHwClockTime Always returns the same dummy values (18-JAN :05:15) RmGetLinAddress Returns the address in the parameter Pointer unchanged as a linear address RmGetMemPoolInfo Structure includes dummy value (0) RmGetPeriodHPET0 RmGetPhysAddress RmGetSpinLock RmGetSpinLockIRQ RmGetSysB Uses the timer with the highest resolution Returns the address in the parameter Pointer unchanged as a physical address Dummy, returns only RM_OK Dummy, returns only RM_OK RmGetSystemPeriod Always returns the value 1 Always returns the same dummy values, some values make sense but the majority are chosen at random 70 Programming and Operating Manual, 07/2009, A5E

73 Testing an RMOS3 application 5.2 RMOS3 simulation on the development PC RMOS3 call Restrictions RmGetSystemTime Always returns the same dummy values (18-JAN :05:15) RmGetTaskID Only applicable for own task RmGetTaskInfo Merely the priority and status are valid, all other values are always 0 RmGetTaskState There are only certain task states RmGetTCBAddress Only applicable for own task RmGetTimeHPET0 Uses the timer with the highest resolution RmInitFastTask Dummy, returns only RM_OK RmInitFastTick Dummy, returns only RM_OK RmInitHPET Uses the timer with the highest resolution RmInitOS Dummy, returns only RM_OK RmInitSpinLock Dummy, returns only RM_OK RmMapMemory Image on malloc, Parameter PhysAddress is not evaluated RmReAlloc Parameter TimeOutValue is not supported RmReleaseSpinLock Dummy, returns only RM_OK RmReleaseSpinLockIRQ Dummy, returns only RM_OK RmRemoveFastTask Dummy, returns only RM_OK RmRemoveFastTick Dummy, returns only RM_OK RmSegToFlatAddress Returns Offset unchanged, Sel is not evaluated RmSendMail Parameter Priority and TimeOutValue are not supported RmSendMailCancel Dummy, returns only mail RmSendMessage Parameter Priority and TimeOutValue are not supported RmSetHwClockTime Dummy, returns only RM_OK RmSetOS Dummy, returns only RM_OK RmSetSMRCount Dummy, returns only RM_OK RmSetSystemTime Dummy, returns only RM_OK RmSuspendTask Only possible for some task FlatByt_RmIO Dummy, returns only RM_OK Unsupported functions The following RMOS3 calls cannot be used in simulation mode because they are configuration calls for the initialization of the operating system. When linking they generate an error: RmCreateOS RmResetOS RmRunOS RmSetPutcharProc RmSetSVC Programming and Operating Manual, 07/2009, A5E

74 Testing an RMOS3 application 5.2 RMOS3 simulation on the development PC The following RMOS3 calls also cannot be used in simulation mode because they are not supported in the FLAT memory model. When linking they generate an error: RmChangeDescriptor RmChangeDescriptorAccess RmCreateDescriptor RmCreateDriver RmCreateMemPool RmDeleteMemPool RmCreateUnit RmDeleteDescriptor RmDeleteDriver RmDeleteUnit RmIO RmMemPoolAlloc RmResumeDriver RmSequenceTask RmSuspendDriver The CLI functions are not supported in the simulation. When linking they generate an error: x_cli_cancel x_cli_cmdexec x_cli_cmdline x_cli_errorlevel x_cli_extended_session x_cli_extended_start x_cli_get_device x_cli_inhibit_abort x_cli_init_manager x_cli_job_command x_cli_job_command_tail x_cli_prompt x_cli_session x_cli_start x_cli_test_abort 72 Programming and Operating Manual, 07/2009, A5E

75 Testing an RMOS3 application 5.2 RMOS3 simulation on the development PC The PCI functions are not supported in the simulation. When linking they generate an error: RmCrlShIntISHandler RmInitShIntClient RmIntShSrv RmPciSearchFunction RmPciSearchSubFunction RmSetShIntISHandler1 RmSetShIntISHandler2 The following special functions are not supported in the simulation. When linking they generate an error: x_bu_init x_bu_get stl_free stl_load x_hd_init x_hd_part GetMaxLengthSerEEPROM ReadSerEEPROM ReadTemperatureCore WriteSerEEPROM changevib checkpoint createvib getvolumestatus remap getw putw seek matherr dismount mount duread duwrite Programming and Operating Manual, 07/2009, A5E

76 Testing an RMOS3 application 5.2 RMOS3 simulation on the development PC errno2 fduopen fdureopen The following calls are not supported in the simulation as they cannot be emulated. They return the error code -1: RmGetIntHandler RmRestartTask RmReserveInterrupt RmSetDeviceHandler RmSetIntDefHandler RmSetIntDIHandler RmSetIntHandler RmSetIntISHandler RmSetIntMailboxHandler RmSetIntTaskHandler The following built-in functions are not supported in the simulation. When linking they generate an error: enable disable getflags setflags causeinterrupt inbyte inhword inword outbyte outhword outword 74 Programming and Operating Manual, 07/2009, A5E

77 Testing an RMOS3 application 5.2 RMOS3 simulation on the development PC Usage with the Eclipse IDE Settings A series of settings are needed for creating an RMOS3 simulation application with the Eclipse IDE (compiler, linker, etc.). If you use the project type Executable (GNU on RMOS), these are preset. As an example for the use of the RMOS3 simulation, the S_TASK example was expanded with the Executable (GNU on RMOS) project type for the GNU. This example is included in the delivery scope and exists in the configurations debug, release and simulation. Note The RMOS3 simulation is available as RMWIN32.DLL. This DLL is located in the <rmos_dir>\simulation\bin directory. This directory must be included in the search path of the computer! It is added to the search path during installation. Programming and Operating Manual, 07/2009, A5E

78 Testing an RMOS3 application 5.2 RMOS3 simulation on the development PC Debugging Debugging Select the C/C++ Local Application entry in the left selection list with the menu command Run Debug Configurations and the Debug Configurations dialog. Press the New button. The pre-configured setting options appear in the right part of the dialog. In the Main tab of the Debug dialog, enter the name of the program you want to execute along with the relative path name 1 (Figure Setting application to be executed). If the Executable (GNU on RMOS) project type is used, enter Simulation/<project>.exe. Figure 5-6 Debug 76 Programming and Operating Manual, 07/2009, A5E

79 Testing an RMOS3 application 5.2 RMOS3 simulation on the development PC Select these settings: For debugging in the simulation configuration: Select gdb/mi as debugger 1 (Figure Select debugger). Select gdb as GDB debugger 2 (Figure Select debugger). Select Standard as GDB command set 3 (Figure Select debugger). No debug server is necessary. Figure 5-7 Select the debugger Programming and Operating Manual, 07/2009, A5E

80 Testing an RMOS3 application 5.2 RMOS3 simulation on the development PC Generating for the target system You can quickly navigate back and forth between configurations with the button shown here 1 (see Figure Build configuration): Figure 5-8 Build configuration 78 Programming and Operating Manual, 07/2009, A5E

81 Diagnostics 6 This section describes the diagnostic options integrated in the Eclipse IDE: Terminal: Setting up a TELNET connection to the target system Profiling: Visualization of the calculation time distribution and the task activities at the target system 6.1 Preference settings You can set the connection data for the Terminal and Profiling functions using the menu command Window Preferences RMOS Target. Here, you can create the settings for a new target system, change the settings of an existing target system, delete a target system, or make a target system the default target system. You can enter several target systems as connection partners. Figure 6-1 Window for target selection Programming and Operating Manual, 07/2009, A5E

82 Diagnostics 6.1 Preference settings Creating a target system Press the Add button 1 (Figure Window for target selection) to create a new target system. The Add new System dialog opens. Here, you can assign the name and set the IP address of the target system. Figure 6-2 Window for new target system Default target Highlight the target system that you currently want to use and confirm your selection as default value by pressing the Make Default button 1 (Figure Window with target tree). The default target system is identified with the * symbol in front of the name of the target system. If only one target system is configured, it will automatically be the default target system. Service You can assign available services to each target system. The "Profiler" service has already been set. When you select a service, you can use the Edit button 2 (Figure Window with target tree) to open a dialog in which you configure the service. Here, you can set the port number for the profiler service. The default setting is Figure 6-3 Window for service settings 80 Programming and Operating Manual, 07/2009, A5E

83 Diagnostics 6.2 Terminal Figure 6-4 Window for target tree Save your settings by pressing the Apply button 3 (Figure Window with target tree). The preference settings are saved in the current workspace. You restore the default settings by pressing the Restore Defaults button 4 (Figure Window with target tree). All target systems are deleted. 6.2 Terminal The terminal plug-in generates a view in the Eclipse IDE which allows one or more target systems to be operated via TELNET. You open the view with the following menu command: Window Show View Other RMOS Terminal. The IP address is adopted from the menu command Window Preferences RMOS Target of the preference settings (see section Preference settings). Use the Settings button 1 (Figure Terminal view) to open a window in which you can set the name of the connection. Here, you can also change the IP address adopted from the preference settings. As soon as you exit the Settings dialog with OK, the plug-in will try to establish the TELNET connection. Programming and Operating Manual, 07/2009, A5E

84 Diagnostics 6.3 Profiling You must first enter a valid user name and a valid password. NOTICE To use the terminal function, the TELNET daemon must be started on the target system. You must enter the user in the TPASSWD file on the target system. Start the RMOS3-CLI with CTRL-R. Start the RMOS3 debugger CTRL-D. Figure 6-5 Terminal view The set IP address is only applied when you open the view from the preference settings. If you change the IP address in the preference settings, the new value will not become effective until you open a new view. Use the New Terminal Connection in Current View button 2 (Figure Terminal view) to open another connection in the same view or to open a different view. See also Preference settings (Page 79) 6.3 Profiling The profiling plug-in allows the user to examine the load distribution and the task activity of the target system. The plug-in comprises the two views Load Distribution and Task Activity. You must start the RMOS3-Profiler RPROF.386 as of version V2.2.4 on the target system to use the profiling plug-in. RPROF.386 [-p=<port>] [ q=<pri>] 82 Programming and Operating Manual, 07/2009, A5E

85 Diagnostics 6.3 Profiling Table 6-1 Call parameters: Parameter function Value range Default value <Port> Port number for TCP/IP communication <Pri> Task priority Detailed information on the RMOS3 Profiler is available in the RMOS3 Reference manual part I, section 5 "Reference of the RMOS3 Profiler commands". NOTICE You cannot make measurements in the Load Distribution and Task Activity views at the same time. They are made one after the other. NOTICE Simultaneous measurements on the target system with the RPROF.386 tool and by the profiling plug-in are not possible. While the user is in the Load Distribution menu in the profiler user interface, load distribution measurements by the profiling plug-in are not possible. The same holds true for measurement of the Task Activity. You can only close the RPROF.386 tool after the measurements when the Load Distribution and Task Activity views have been closed The Load Distribution view The Load Distribution view shows the percentile load of the individual processor cores and the percentile load of the overall system for each task during a measurement. Open the view with Window Show View Other RMOS Profiler Load Distribution. The IP address and the port number of the target system that was set as default target system in the preference settings under the menu command Window Preferences RMOS Target (see section Preference settings) are displayed in the status bar. These settings are only applied when you open the view from the preference settings and remain as long as the Load Distribution view is open. The line below indicates the duration of the measurement. The evaluation consists of two parts. The left part shows the CPU load in percentage with the help of bars. There is one bar for each processor core for "Task", "S-State", and "Idle Time". This means there may be six bars for two processor cores. The right part of the view shows the load distribution of all tasks in a table. You can sort the table by clicking a column header after this column. There are two buttons below the load distribution table for starting and stopping the measurement. Programming and Operating Manual, 07/2009, A5E

86 Diagnostics 6.3 Profiling To start the measurement, press the Start button 1 (Figure Profiler Load Distribution view). Figure 6-6 Profiler Load Distribution view You can call a dialog using the menu in the title bar of the view 2 (Figure Profiler Load Distribution view) in which you can select the type of measurement: The view is updated every ten seconds with the Cyclic setting. The measured values are added up. The measurement continues until you press the Stop button. With the Autostop setting, the measurement ends automatically upon expiration of the configured time. You can set a time period between 1 and ms (approx. 24 days and 20 hours). The measured values are displayed at the end of the measurement. With the Manual setting, recording will continue after pressing the Start button until you press the Stop button. The measured values are displayed at the end of the measurement. The measurement type is preset. Figure 6-7 Dialog for selection of measurement type The Settings dialog is only available when no measurement is running. 84 Programming and Operating Manual, 07/2009, A5E

87 Diagnostics 6.3 Profiling See also Preference settings (Page 79) The Task Activity view The Task Activity view shows the individual SVC calls and the interrupts carried out during a measurement with a time stamp. Open the view with Window Show View Other RMOS Profiler Task Activity. The IP address and the port number of the target system that was set as default target system in the preference settings under the menu command Window Preferences RMOS Target (see section Preference settings) are displayed in the status bar. These settings are only applied when you open the view from the preference settings and remain as long as the Task Activity view is open. The line below indicates the duration of the measurement. The measurement result is displayed in a table whose columns can be sorted by pressing the respective column header. There is a note field below the table in which messages are output. Next to or below this note field there are buttons for starting, stopping, and saving the measurement. Figure 6-8 Profiler Task Activity view Programming and Operating Manual, 07/2009, A5E

88 Diagnostics 6.3 Profiling You open the Settings and Filters dialogs with the menu in the title bar of the view 1 (Figure Profiler Task Activity view); you can use these dialogs to configure the measurement or the visualization of the measurement. To start the measurement, press the Start button 2 (Figure Profiler Task Activity view). You end the measurement depending on the configured measurement type. You can save the measurement results in a text file as a list separated with semicolons by pressing the Save button 3 (Figure Profiler Task Activity view). You can import this file into Microsoft Excel. Use the Microsoft Excel import function for this purpose and select ";" as separator, and "Text" type as data format of the columns. Settings dialog You have the following setting options in the Settings dialog: Specifying the buffer size (Buffer size) for the measurement: 32, 64, 128 and 256 KB can be set. You can also enter your own value. The default value is 32 KB. The maximum value is 1024 KB. The buffer is managed as ring buffer. The oldest measured value generated is specified with the time 0 ms. This means the displayed time does not refer to the start of the measurement but is specified relative to the oldest value in the ring buffer. Restriction of measurement for certain tasks: Highlight the selection Specified Task IDs in the Task Selection field and enter a maximum of 5 Task IDs. This restriction only applies to SVCs not for special states, such as TASKIN. All tasks are measured by default. Limitation of measurement to certain SVCs: All SVCs including special states (TASKIN, TASKOUT...) All SVCs excluding special states (TASKIN, TASKOUT...) Only specified SVCs These can be selected in a list on the right side of the dialog. The default setting is "All SVCs including special states (TASKIN, TASKOUT...)". The SVC RmInterruptHandler is a collective term for the following SVCs: RmGetIntHandler RmReserveInterrupt RmRestoreIntHandler RmSetIntDefHandler RmSetIntDIHandler RmSetIntHandler RmSetIntISHandler RmSetIntMailboxHandler RmSetIntTaskHandler 86 Programming and Operating Manual, 07/2009, A5E

89 Diagnostics 6.3 Profiling Autostop option with adjustable measurement period: If you select the autostop option, the measurement is automatically ended after the configured time period has expired. The time period can be set to a value between 1 and ms (approx. 24 days and 20 hours). If autostop is not selected, manual measurement is active (default setting). Figure 6-9 Settings dialog The Settings dialog is only available when no measurement is running. Programming and Operating Manual, 07/2009, A5E

90 Diagnostics 6.3 Profiling Filters dialog You use the Filters dialog to filter the display of measurement results. The following filter options are available: Filtering by the Name column Filtering by the Action column Only the selected task or action names are displayed in the table in the Profiler Task Activity view. Figure 6-10 Filters dialog The Filters dialog is only available if a complete measurement is available and a new measurement has not been started. See also Preference settings (Page 79) 88 Programming and Operating Manual, 07/2009, A5E

91 Converting from RMOS3-GNU V2.x to V3.0 7 Converting Eclipse IDE projects RMOS3-GNU version Included Eclipse IDE version Included CDT version The project format with CDT has changed. Therefore, projects created with RMOS3- GNU V2.x must be converted if they are to be generated under RMOS3-GNU V3.0. The following describes only the conversion of managed make projects. The conversion of standard make projects can be derived from the CDT online help. In addition to project conversion, it is also possible to set up a new project with the Executable (GNU on RMOS) type and copy in the source files of the old project. Programming and Operating Manual, 07/2009, A5E

92 Converting from RMOS3-GNU V2.x to V3.0 Converting without workspace To import an existing RMOS3-GNU V2.x project into RMOS3-GNU V3.0, select Window OpenPerspective C/C++. Then select File Import Existing Projects into Workspace (Figure Import project). Figure 7-1 Import project Another window opens after pressing the Next button. Here, select the project you want to import. Confirm your selection by pressing the Finish button. 90 Programming and Operating Manual, 07/2009, A5E

93 Converting from RMOS3-GNU V2.x to V3.0 The following note appears: Figure 7-2 Converting project format NOTICE You will not be able to read this project after conversion with RMOS3-GNU V2.x! Click the Yes button to convert the project into the new format. NOTICE You have to manually update the settings of the Strip tool for the example projects included in RMOS3-GNU V2.x or for the examples you have created yourself. You open the Strip tool dialog under Project Properties Builders. You adapt the path of the Strip tool under the entry Location: ${env_var:cygwin_home}\usr\local\i586-rmos-elf\bin\rm-strip.exe Replace it with ${env_var:msys_home}\1.0\local\bin\rm-strip.exe NOTICE Check the configured value after conversion for projects in which you have set the optimization level to deviate from the standard values. Programming and Operating Manual, 07/2009, A5E

94 Converting from RMOS3-GNU V2.x to V3.0 Converting Make file projects If you want to convert a project you have created with a Make file from the command line from RMOS3-GNU V2.x to RMOS3-GNU V3.0, you need to make the following change: Replace the g compiler switch with the ggdb switch in the Make file for the Debug version and the Simulation version. 92 Programming and Operating Manual, 07/2009, A5E

95 Example of application generation Description of example In the following example, the RMOS3 application MyGnu is created step-by-step with Eclipse IDE. The Executable (GNU on RMOS) project type is used. Steps As a starting basis, a simple C program is chosen which is easy to understand. Step Description 1 Creating the MyGnu project 2 Creating the C program file 3 Entering the C program 4 Setting the compiler parameters 5 Setting the linker parameters 6 Activating the project settings 7 Configuring the strip tool 8 Compiling and linking the project Created application After the successful transmission to the target system and the launch of the application MyGnu the following message must appear: Hello RmosGNU Program terminated. Programming and Operating Manual, 07/2009, A5E

96 Example of application generation 8.2 Creating the MyGnu project 8.2 Creating the MyGnu project Selecting the wizard To create a new project, open the New Project dialog by selecting the menu command File New Project... In this dialog, select the entry C in the tree and the sub-command C Project 1 (Figure Selecting the wizard). Confirm your selection with the Next button 2 (Figure Selecting the wizard). Figure 8-1 Selecting the wizard 94 Programming and Operating Manual, 07/2009, A5E

97 Example of application generation 8.2 Creating the MyGnu project Creating a project In the subsequent dialog, enter the project name MyGnu in the Project name input field 1 (Figure Creating the project). Select Executable (GNU on RMOS) as project type in the Project type tree 2 (Figure Creating the project) and press the Next button 3 (Figure Creating the project). Figure 8-2 Creating a project Programming and Operating Manual, 07/2009, A5E

98 Example of application generation 8.2 Creating the MyGnu project Selecting the configurations The release, debug, and simulation configurations are preset 1 (Figure Selecting the configurations). Confirm your selection with the Finish button 2 (Figure Selecting the configurations). Figure 8-3 Selecting the configurations 96 Programming and Operating Manual, 07/2009, A5E

99 Example of application generation 8.3 Creating the C program file Set up project An empty project node with the name MyGnu appears in the Project Explorer window 1 (Figure Eclipse IDE with new project). Figure 8-4 Eclipse IDE with new project 8.3 Creating the C program file To create a new C program file, right-click the MyGnu project node. Enter the file name MyGnuMain.c using the menu command New Source File in the Source File input field of the New Source File dialog. You can select a template for the C program file you want to create in the Template input field (for example, Default C source template). Programming and Operating Manual, 07/2009, A5E

100 Example of application generation 8.4 Entering the C program 8.4 Entering the C program 1. Enter the following C program in the MyGnuMain.c window. 2. Save the file. #include <rmapi.h> #include <stdio.h> void trace(int value); int main(){ int i=0; printf("hello RmosGNU.\n"); } while(i<100){ } trace(i); i++; printf("program terminated.\n"); return (0); void trace(int value){ if((value%10)==0){ } } <Empty line> printf("%i\n",value); RmPauseTask(100); 8.5 Setting the compiler parameters Properties menu command To change the compiler settings, right-click the project node named MyGnu in the Project Explorer window. Via the menu command Properties the dialog Properties for MyGnu appears. Here, select the C/C++ Build Settings entry in the left selection box 1 (Figure Setting compiler switches). Configuration Use the Configuration selection box to select the configuration for which these settings are to be applied. You can also make the settings for several selected configurations (Multiple configurations...) or for all available configurations (All configurations). 98 Programming and Operating Manual, 07/2009, A5E

101 Example of application generation 8.5 Setting the compiler parameters Compiler switches All compiler switches necessary for creating an RMOS3 application are already set. If a compiler switch is to be set to a specific value, select the command rm-gcc C Compiler Symbols in the Tool Settings field 2 (Figure Setting compiler switches). Then enter the compiler switch with the associated value in the form <name>=<value> in the Defined symbols (-D) field. To do this, use the button for creating a new entry 3 (Figure Setting compiler switches). Figure 8-5 Setting compiler switches Note If no value is given with a set compiler switch, then this implicitly obtains the value 1. In the example application it is not necessary to set the compiler switches. Programming and Operating Manual, 07/2009, A5E

102 Example of application generation 8.5 Setting the compiler parameters Include paths ${RMOS_HOME}/inc is preset as the include path. If this include path must be expanded by application-specific include paths, do this by selecting the command rm-gcc C Compiler Directories 1 (Figure Include paths) in the Tool Settings field and the button for creating a new entry 2 (Figure Include paths). This is not necessary in the example application MyGnu. Figure 8-6 Include paths 100 Programming and Operating Manual, 07/2009, A5E

103 Example of application generation 8.5 Setting the compiler parameters Debug version If a debug version is to be created instead of the release version, select the Debug entry in the Properties for MyGnu dialog in the Configuration selection field 1 (Figure Debug options). Figure 8-7 Debug options Programming and Operating Manual, 07/2009, A5E

104 Example of application generation 8.5 Setting the compiler parameters List Files To create a list file enter the option -Wa,-a[<suboption>]=<list file> in rm-gcc C Compiler Miscellaneous Other flags. If you want to generate a list file for each individual source file, add the following after ${FLAGS} for the rm-gcc C Compiler Command line pattern: Wa,-a[<suboption>]=${OUTPUT}.lst Figure Creating list files See also C compiler (Page 16) 102 Programming and Operating Manual, 07/2009, A5E

105 Example of application generation 8.6 Setting the linker parameters 8.6 Setting the linker parameters All linker parameters required for a standard RMOS3 application are preset. RMOS3-specific settings All necessary settings are preset for the Executable (GNU on RMOS) project type. Figure 8-9 Linker switches Programming and Operating Manual, 07/2009, A5E

106 Example of application generation 8.6 Setting the linker parameters Add libraries For an RMOS3 application, the libraries listed under Tool Settings rm-gcc C Linker Libraries 1 (Figure Adding libraries) are preset. To add additional libraries, press the button for creating new entries 2 (Figure Adding libraries). The path required for the preset libraries ${RMOS_HOME}/lib/gnu is preset. To add additional library paths, press the button for creating new entries 3 (Figure Adding libraries). Figure 8-10 Inserting libraries 104 Programming and Operating Manual, 07/2009, A5E

107 Example of application generation 8.6 Setting the linker parameters Xlinker options All necessary settings are preset for the Executable (GNU on RMOS) project type. Figure 8-11 Xlinker options Map Files To create a map file enter the -Wl,-Map,<map file> option in rm-gcc C Linker Miscellaneous Linker flags. Programming and Operating Manual, 07/2009, A5E

108 Example of application generation 8.7 Setting the assembler parameters 8.7 Setting the assembler parameters All necessary settings are preset for the Executable (GNU on RMOS) project type. These settings are available under Tool Settings rm-as assembler General 1 (Figure Assembler include paths). Figure 8-12 Assembler Include Paths 106 Programming and Operating Manual, 07/2009, A5E

109 Example of application generation 8.8 Activating the project settings 8.8 Activating the project settings After all compiler and linker parameters have been set, you can activate these parameters with the OK button 1 (Figure Activating project settings). Figure 8-13 Activating project settings Programming and Operating Manual, 07/2009, A5E

110 Example of application generation 8.9 Configuring the strip tool 8.9 Configuring the strip tool Select the Builders entry using the Project Properties menu 1 (Figure Dialog builders) and press the New 2 button (Figure Dialog builders). Figure 8-14 Dialog builders After pressing the button New a dialog appears for selecting the type of the external tool. You select the Program type by double-clicking it 1 (Figure Selection dialog for the type of external tool). 108 Programming and Operating Manual, 07/2009, A5E

111 Example of application generation 8.9 Configuring the strip tool Figure 8-15 Selection dialog for the type of external tool In the subsequent dialog, you can configure the Strip tool (Figure Strip tool). Figure 8-16 Strip tool Strip_MyGnu is called when you generate in the debug and release configuration, but only effects the release.exe file. Programming and Operating Manual, 07/2009, A5E