PRACTICE is a line-oriented test language which can be used to solve all usual problems of digital measurement engineering. PRACTICE-II is an enhanced version of this test language, first developed in

1984 for in-circuit emulators.

The test language allows interactive script development with the possibility of a quick error removal and an immediate script execution. The execution of PRACTICE testing scripts can be stopped and restarted at any time.

PRACTICE contains an extremely powerful concept for handling script variables and command parameters.

This macro concept allows to substitute parameters at any point within the commands. Since PRACTICE variables can only occur as PRACTICE macros, conflicts between target program names are ruled out.

Difference between Variables and PRACTICE Macros

PRACTICE macros are based on a simple text replacement mechanism similar to C preprocessor macros.

However, in contrast to C preprocessor macros, a PRACTICE macro can change its contents during it’s life time by simply assigning a new value.

Each time the PRACTICE interpreter encounters a macro it is replaced with the corresponding character sequence. Only after performing all text replacements the resulting line is interpreted (just like the C compiler only works on the fully preprocessed text).

PRACTICE macros are declared using

LOCAL

PRIVATE

commands and are accessible (“alive”) until the declaring the block is left.

•

The visibility of PRACTICE macros differs notably from other script languages (unless declared using the

PRIVATE

command): they are accessible from all subsequently executed code while they are alive e.g. in:

Subroutines (

Sub-scripts (

GOSUB

...

RETURN

ENDDO

)

• Sub-blocks (

...,

RePeaT

WHILE

, etc.)

NOTE:

PRACTICE does not know the concept of variables with a corresponding type like uint32 or uint8 in C.

PRACTICE Script Language User’s Guide

PRACTICE Script Structure

PRACTICE Script Elements

PRACTICE scripts consist of labels, commands, and comments:

;example

//example start:

Step

GOTO start

B:Data.dump

comment starting with

;

comment starting with

label command command command to change the default device command preceded by a device selector

Devices

The device selection command is used to specify one of multiple devices (e.g. PowerDebug, PowerProbe,

PowerIntegrator, stimuli generators) that are controlled via a common PowerView GUI. The currently selected device is indicated by a device prompt like

B:: debugger, e.g. BDM/JTAG debugger,

E:: in circuit emulator.

Labels

Labels always start in the first column

and are always followed by a colon.

Commands

Only one command may be used in each line.

The device prompt or a command preceded by a device prompt have to be placed behind at least one space.

❚E::Data.dump 0x1000

Comments

Comments are prefaced by a semicolon

;

Inline comments for Var.* commands must start with

Var

.set func7(1.5,2.5)

execute a function in the target

Line Continuation Character

To continue a string on the next line, a backslash

is used to indicate a line continuation in a

PRACTICE script (*.cmm). No white space permitted after the backslash.

DIALOG.OK "Please switch ON the TRACE32 debugger first"+

" and then switch ON the target board."

PRACTICE Script Language User’s Guide

PRACTICE Script Structure

Script Flow

Several commands allow to control the script flow. Scripts may be divided in several modules. Subroutines within a module are called by the GOSUB command, another module is called by the DO command.

STOP

END

CONTinue

ENDDO

RUN

GOSUB

RETURN

GOTO

JUMPTO

Stop temporarily

Terminate script and clear stack

Continue with script execution

Call script module

Terminate script module

Clear PRACTICE stack and call module

Call subroutine

Return from subroutine

Branch within module

Branch to other module

PRACTICE Script Language User’s Guide

PRACTICE Script Structure

Conditional Script Flow

Conditional script execution is made by several commands:

ELSE

WHILE

RePeaT

GLOBALON

WAIT

Conditional block execution

Block that is only compiled when the IF condition is false

Conditional script loop

Repetitive script loop

Event-controlled PRACTICE script execution

Global event-controlled PRACTICE script execution

Wait for event or delay time

IF OS.FILE(data.tst)

PRINT "File exists"

ELSE

PRINT "File doesn't exit"

WHILE Register(pc)==0x1000

Step

RePeaT 100. Step

RePeaT 0. Step

ON ERROR GOTO errorexit

; step until pc = 1000H

; step 100 times

; step endless

For detailed information on logical operations refer to

chapter “Operators”

”IDE User’s Guide”

(ide_user.pdf).

Script Nesting

PRACTICE scripts can be nested hierarchically. A second script may be called as a subroutine from the initial script. This subroutine on its part may call up a third script as a subroutine. This allows a structured, modular script development.

; Script containing two script calls

PRINT "Start"

DO modul1

DO modul2

ENDDO

; Execute script module 1

; Execute script module 2

PRACTICE Script Language User’s Guide

PRACTICE Script Structure

Block Structures

Several PRACTICE commands can be combined to form a block. A block is a collection of commands, which are always executed simultaneously. Blocks usually require

WHILE

RePeaT

statements. They can, however, be implemented anywhere in order to mark connective blocks. Blocks are marked by round parenthesis. You can jump out of a block, but not into a block.

; Block nesting start:

IF &abc

(

PRINT "Function 1"

DO func1

)

ELSE

(

PRINT "Function 2"

DO func2

IF &xyz GOTO start

ENDDO

)

PRACTICE Script Language User’s Guide

PRACTICE Script Structure

PRACTICE Macros (Variables)

PRACTICE macros are character sequences with a maximum size of 4KB. The character sequence is interpreted in the context where it is used. For a command, a PRACTICE macro can be interpreted e.g. as a number, boolean expression, parameter, or simply as a string. PRACTICE macros can be expanded to complete commands, too.

PRACTICE macros are generated by an allocation. PRACTICE macros found in a command file line are replaced by the text they contain (except special commands, e.g.

ENTRY

). The macros can be put into braces, if necessary. The double ampersand form (’&&’) of the assignment forces a recursive macro resolution if the resolved value still contains macro names. Macros may be defined and modified inside the interactive command line.

Macro expansion does not take place inside the interactive command line of the GUI!

e.g.

PRINT &macroname

Data.List &my_startaddress or fail inside the interactive command line even if the macros really exist.

normal: recursive:

&<macroname>=<value>

&&<macroname>=<value>

&int=1

&int=&int+1

&text="This is a test"

&command="Data.dump Register(PC)"

&float=1.4e13

&range="0x1000--0x1fff"

&address=func5

&addressrange=P:0x1234..0x5555

&boolean=SYStem.UP()

PRINT &int

PRINT "&int"

PRINT "&(int)nd"

ENDDO

; increment current value of &int

; after replacement: 0x2

; after replacement: "2nd"

PRACTICE macros may be set to LOCAL or GLOBAL or PRIVATE. A global macro is accessible at every script level, a local macro only within this block. A private macro exists in the declaring block and in all subblocks. If no attribute is used, the macro type will be local to this block.

LOCAL

GLOBAL

PRIVATE

Define local macro

Define global macro

Define private macro

PRACTICE Script Language User’s Guide

PRACTICE Script Structure

Parameter Passing

The passing of parameters to a subroutine is done with a parameter list. The parameters are assigned to local PRACTICE macros, using the

ENTRY

command within the subroutine. Subroutines can also be called up interactively by parameters. Arguments can be passed by the commands

ENDDO

RUN

GOSUB

RETURN

. They can also be the result of calling a command extension or invoking the driver program on the host with arguments.

ENTRY

Parameter passing

; By the subroutine call GOSUB TEST 0x0--0xfff

; a memory test as of address 0x0 to 0x0fff can be executed

TEST:

ENTRY &range

Data.Test &range

RETURN

PRACTICE Script Language User’s Guide

PRACTICE Script Structure

Input and Output

Several input and output commands allow interaction with the user. Input is normally done through an AREA window. All print operations are displayed on the message line. The

AREA

window A000 is displayed on default. Inputs and outputs can be re-routed to another AREA window.

PRINT

BEEP

ENTER

INKEY

Print to screen

Stimulate sound generator

Window based input

Character input

PRINT "The PC address is " Register(pc)

BEEP

INKEY

INKEY &char

IF &char=='A'

GOSUB func_a

IF &char=='B'

GOSUB func_b

…

AREA.Create IO-Area

AREA.Select IO-Area

AREA.view IO-Area

PRINT "Set the PC value"

ENTER &pc

WINClear TOP

AREA.RESet

ENDDO

; print message

; end acoustic signal

; wait for keystroke

; create a window

; select this window for

; PRACTICE I/O

; open this window

; print text

; get value

; set register PC

; delete I/O window

; reset AREA system

The screen update may be controlled by the SCREEN commands.

SCREEN.display

SCREEN.ALways

SCREEN.ON

SCREEN.OFF

Update screen

Update screen after every command line

Update screen on print commands

Don't update screen as long as script is running

PRACTICE Script Language User’s Guide

PRACTICE Script Structure

File Operations

Test data can be written to and read from files. Files must be opened first before accessing them.

OPEN

CLOSE

READ

WRITE

APPEND

Open file

Close file

Read data from file

Write data to file

Append data to file

In this example, a new file called test.dat is created, and register information is written to the newly created file. The result is then displayed in a

TYPE

window.

OPEN #1 test.dat /Create

WRITE #1 "PC: " Register(pc)

WRITE #1 "SP: " Register(sp)

CLOSE #1

TYPE test.dat

ENDDO

In this example, the test.dat file is opened for reading. Two lines are read from this file and stored in two

PRACTICE macros, which are then printed to the TRACE32 message line.

OPEN #1 test.dat /Read

READ #1 %LINE &pc ;line 1 of file

READ #1 %LINE &sp ;line 2 of file

CLOSE #1

PRINT "&pc " "&sp"

ENDDO

PRACTICE Script Language User’s Guide

File Operations

Automatic Start-up Script

The script t32.cmm is searched for within the current working directory and in the TRACE32 system directory. By default, the TRACE32 system directory is C:\T32. If found, the t32.cmm file will be executed as a PRACTICE script.

The parameters of the driver program are passed to the t32.cmm script in the usual way; see

“Parameter

Passing”

, page 9.

The command

SETUP.RESTARTDO

defines a script that is executed when the emulator is restarted after an

ABORT

command.

; start TRACE32 system t32win.exe test1 ; former t32w95.exe

; t32.cmm is started automatically and

; runs the command argument as a PRACTICE file

LOCAL &fname

ENTRY &fname

DO &fname

ENDDO

PRACTICE Script Language User’s Guide

Automatic Start-up Script

Debugging PRACTICE Scripts

TRACE32 supports extensive debugging features for PRACTICE scripts. The PEDIT command allows you to create and edit PRACTICE scripts. Two basic windows show the script and the internal stack and the

PRACTICE macros.

PEDIT

PLIST

PMACRO.list

Edit PRACTICE scripts

List PRACTICE script

List PRACTICE script nesting and PRACTICE macros

(variables)

In a PLIST window, you can set an unlimited number of program breakpoints to debug your PRACTICE scripts. Double-clicking an entire line sets a breakpoint; double-clicking the same line again removes the breakpoint. That is, you can toggle breakpoints by double-clicking a line.

Alternatively, right-click a line, and then select Toggle breakpoint from the popup menu.

PRACTICE breakpoints are listed in the PBREAK.List

window.

Disabled

Enabled

Line numbers

Script nesting

Double-clicking a line toggles a breakpoint (set/delete).

Enabled breakpoints are flagged with a small red bar, disabled breakpoints are flagged with a small gray bar in the PLIST window.

PBREAK.Set

PBREAK.Delete

PBREAK.List

PBREAK.ENable

PBREAK.DISable

Set breakpoints in PRACTICE scripts

Delete breakpoints

Display breakpoint list

Enable breakpoint

Disable breakpoint

PRACTICE Script Language User’s Guide

Debugging PRACTICE Scripts

The

PMACRO.list

window shows the script nesting, the local and global PRACTICE macros and the ON and GLOBALON definitions:

Local macros

Global macros

Local macro

Double-click to modify the parameter.

Double-clicking a PRACTICE macro (e.g. &val1) inserts it into the TRACE32 command line, where you can modify the parameter of the PRACTICE macro.

Scripts can be executed step by step with the PSTEP command. The Stop button in the TRACE32 main toolbar stops any running PRACTICE script.

PSTEP

<script> Start script to be debugged in single step mode

PBREAK.Set 4. test.cmm

DO test.cmm

PSTEP

; set breakpoint

; run till line 4

; single step

PRACTICE Script Language User’s Guide

Debugging PRACTICE Scripts

External Editors and Syntax Highlighting

•

TRACE32 provides built-in editors for different file types, such as:

•

PEDIT

for PRACTICE script files (*.cmm)

•

MENU.Program

MCDS.Program

for menu files (*.men)

DIALOG.Program

for dialog files (*.dlg)

for OCTL files (*.octl)

In addition to the built-in TRACE32 editors, you can configure an external editor. Syntax highlighting files for external editors reside under ~~\demo\practice\syntaxhighlighting and are available for the following external editors: TextPad, UltraEdit, Kate, and Notepad++

The syntax highlighting files cover the TRACE32 file types *.cmm, *.men, *.dlg, and *.octl.

Configuring an External Editor

Before configuring an external editor for use in TRACE32, you should consult the online help of your favorite external editor for information about a) syntax highlighting files or syntax definition files and b) command line parameters for file name and line number.

Background information is also provided in the headers of the syntax files and in the readme.txt residing under ~~\demo\practice\syntaxhighlighting

To configure an external editor for TRACE32:

In your TRACE32 system directory, navigate to

~~\demo\practice\syntaxhighlighting\<editor>

Copy the required syntax highlighting file, and paste it into the folder where your external editor expects syntax highlighting files.

The remaining steps for registering a syntax highlighting file are specific to the external editor.

In TextPad, for example, you need to create a new document class and assign the TRACE32 file types *.cmm, *.men, and *.dlg to this new document class.

Look up the examples and description of the following TRACE32 command. They tell you how to replace the TRACE32 editor call with an external editor call.

SETUP.EDITEXT

Define an external editor

PRACTICE Script Language User’s Guide

External Editors and Syntax Highlighting

Working with TRACE32 and the External Editor

The interaction between TRACE32 and external editor allows you to take advantage of the combined features of both applications. For example, after saving your PRACTICE script in the external editor, you can immediately execute and/or debug your script in TRACE32.

To work with TRACE32 and the external editor in parallel:

Run the

PSTEP

and

EDIT

commands for the same PRACTICE script file. For example:

PSTEP c:\temp\demo.cmm ;open file in the PSTEP window

EDIT c:\temp\demo.cmm ;open same file in the external editor

In the external editor, type your PRACTICE script. Let’s use this very simple demo script:

AREA.view ;display the default AREA window

AREA.RESet ;reset the AREA window

RePeaT 10. ;repeat the PRINT command

PRINT "Hello TRACE32!"

ENDDO

In TRACE32, right-click the window caption of the

PSTEP

window, and then press Enter.

The saved PRACTICE script file is loaded into the

PSTEP

window.

You are now ready to step through your script line by line (STEP button), execute it (Continue button), set PRACTICE breakpoints (see

PBREAK

NOTE:

If your script starts with a

WinCLEAR

command, you can prevent the

PSTEP

window from being erased by opening it with the

WinResist

pre-command.

In our example: WinResist.PSTEP c:\temp\demo.cmm

PRACTICE Script Language User’s Guide

External Editors and Syntax Highlighting

Appendix A

In this appendix:

• Here are a few suggestions how to run demo scripts you have copied from the pdf manuals:

Create PRACTICE script on the fly [ more ].

Create a permanent toolbar button for a test.cmm [ more

•

Run a copied script as an embedded script [

more ].

Run a demo script from the TRACE32 ~~\demo folder [

more ].

How to Run Demo Scripts Copied from the PDF Manuals

The pdf manuals provide a few read-to-run demo scripts (in addition to the PRACTICE script segments). One way to try these demo scripts is to create a test.cmm in the PEDIT window, copy a demo script from the pdf manual, paste the demo script into the *.cmm file, and then execute it.

For how-to information, see step-by-step procedure below.

Create a PRACTICE Script on the Fly

At the TRACE32 command line, type:

PEDIT ~~~/test.cmm

The PRACTICE script editor opens, displaying the test.cmm. The path prefix ~~~ expands to the temporary directory of TRACE32.

Paste the demo script that you have copied from a manual into the test.cmm.

Append

ENDDO

at the end of the demo script (if ENDDO is missing from the demo script).

Click Save.

To step through line by line, click Debug in the

PEDIT

window, and then Step in the

PLIST

window.

To execute the PRACTICE script file, click Do in the

PEDIT

window.

Optionally, click Macro to view the PRACTICE stack frame.

PRACTICE Script Language User’s Guide

Appendix A

Create a Permanent Toolbar Button for the test.cmm

Add the following to C:\T32\t32.cmm:

MENU.AddTool "My test" "TS,R" "PEDIT ~~~/mytest.cmm"

Restart TRACE32.

Click the new toolbar button to open the PRACTICE script editor.

PRACTICE Script Language User’s Guide

Appendix A

Run a Demo Script as an Embedded Script

To reproduce the following step-by-step procedure, we suggest that you copy this demo script:

;set a test pattern to the virtual memory of TRACE32

Data.Set VM:0--0x2f %Byte 1 0 0 0

Data.dump VM:0x0 ;open the Data.dump window

;visualize the contents of the TRACE32 virtual memory as a graph

Data.DRAWFFT %Decimal.Byte VM:0++0x4f 2.0 512.

To run a demo script as an embedded script:

Copy the demo script from the pdf manual.

At the TRACE32 command line, type PLIST to open a

Click Enddo until the

PLIST

window displays no script.

PLIST

window.

Click Step. The

PLIST

window displays single step.

Paste the demo script into the TRACE32 command line.

Result:

Do one of the following:

Click Continue to run the embedded script.

Click Step to step through line by line.

PRACTICE Script Language User’s Guide

Appendix A

Demo Scripts from the TRACE32 Demo Folder

Using the Search for scripts window in TRACE32, you can search for PRACTICE demo scripts in your local TRACE32 demo folder as well as for the newest scripts on the Lauterbach website.

The Search for scripts window displays a brief description for each script you have selected, with the descriptions being extracted from the metadata in the script header. Double-clicking a script lets you preview the source code of a script before running it.

Prerequisites:

• Software Release from 1-Sep-2014 or higher.

• The files t32.cmm and t32.men must also be from the 1-Sep-2014 release or higher. If these two files date from a release earlier than 1-Sep-2014, the new menu option Search for Script will not be available.

To search for demo scripts in your local TRACE32 demo folder:

Choose File menu > Search for Script to open the window of the same name.

Under Example search, enter what you are looking for, e.g. a chip or board name.

The wildcard (*) is supported.

Optionally, set the filter to Chip or Board.

Click Search.

The demo scripts meeting the search criteria are listed at the bottom of the window.

Continues your search at

www.lauterbach.com/scripts.html

PRACTICE script templates are highlighted in gray, ready-to-run scripts are highlighted in blue.

Allows you to add your own search paths to the demo script search.

Clicking the column header changes the sort order.

PRACTICE Script Language User’s Guide

Appendix A

To preview and run a demo script:

Click a script to automatically switch to the Selection tab, where you can view a brief description of the selected script [A].

To view the source code of a script in the

PSTEP

window, double-click the script or right-click, and then click View/Start from the popup menu.

To run the script, click Continue in the

PSTEP

window.

Popup Menu - Option

View/Start

Edit

Open Folder

New Search

Tree view

Description

Opens the script in the

PSTEP

PEDIT

window.

Opens the file explorer and selects the script file.

Switches to the Search tab, where you can start a new search.

Displays an file-explorer-like tree view of the folders and demo scripts.

PRACTICE Script Language User’s Guide

Appendix A

Hej! Jag är en AI-chattbot som är särskilt tränad för att hjälpa dig med Lauterbach PRACTICE Script Language Användarhandbok. Jag har noggrant granskat dokumentet och kan hjälpa dig att hitta den exakta information du behöver eller förklara innehållet på ett tydligt och enkelt sätt. Oavsett om du letar efter vägledning om specifika funktioner, felsökningssteg eller allmän användning, tveka inte att ställa dina frågor. Ju mer detaljer du ger om dina bekymmer eller behov, desto mer exakt och effektivt kan jag hjälpa dig!

Assistent skriver

Assistenten är inte tillgänglig. Försök igen senare.

Det ser ut som att du har kommit till ett dokument som är skrivet på flera språk, inklusive ett som inte är ditt modersmål. Du kan använda följande länkar för att tillfälligt dölja sidor utan det språk du föredrar.