Daqarta
Data AcQuisition And Real-Time Analysis
Scope - Spectrum - Spectrogram - Signal Generator
Software for Windows
Science with your Sound Card!
The following is from the Daqarta Help system:

Features:

Oscilloscope

Spectrum Analyzer

8-Channel
Signal Generator

(Absolutely FREE!)

Spectrogram

Pitch Tracker

Pitch-to-MIDI

DaqMusiq Generator
(Free Music... Forever!)

Engine Simulator

LCR Meter

Remote Operation

DC Measurements

True RMS Voltmeter

Sound Level Meter

Frequency Counter
    Period
    Event
    Spectral Event

    Temperature
    Pressure
    MHz Frequencies

Data Logger

Waveform Averager

Histogram

Post-Stimulus Time
Histogram (PSTH)

THD Meter

IMD Meter

Precision Phase Meter

Pulse Meter

Macro System

Multi-Trace Arrays

Trigger Controls

Auto-Calibration

Spectral Peak Track

Spectrum Limit Testing

Direct-to-Disk Recording

Accessibility

Applications:

Frequency response

Distortion measurement

Speech and music

Microphone calibration

Loudspeaker test

Auditory phenomena

Musical instrument tuning

Animal sound

Evoked potentials

Rotating machinery

Automotive

Product test

Contact us about
your application!

Macro Variables


Macros: Var0-VarZ, VarClr, A-Z

Introduction:

Unlike main Daqarta controls such as TrigLevel or ToneFreq, setting a macro variable doesn't "do" anything by itself; any action is completely dependent on how the variable is used in your macros.

Just like main Daqarta control values, macro variables can be set, tested in IF statements or WHILE loops, or used in expressions for various calculations. They can also be used as string variables in messages, Labels, Fields, file names, Notes, Custom Meters Mtr0-Mtr3, or log text.

There are two main types of simple macro variables: Fixed-point (Var0 through Var9 and VarA through VarZ), which are the only variables persistent across Daqarta sessions, and floating-point (A through Z). In addition, macros have access to all MIDI Changes Script User Variables. Each variable type is discussed below.

There are also special Macro Arrays Buf0-Buf7 which can be used as collections of 64-bit fixed-point variables for many purposes. Memory Arbs are arrays of 16-bit signed integers that can be up to 16384 elements long.

All macro and MIDI variables can be directly set using constants, variables, or expressions. In addition, you can scroll by +/-1.00 using the form A=>X, where X is a constant, variable, or expression. If X is positive then A is incremented by 1. If negative it is decremented by 1, and if 0 it is unchanged.

In addition, you can set these same variables using quoted strings of 4 characters or less, as in VarA="PASS" or UZ="FAIL". These strings can be displayed or sent to a Log file using the alphanumeric (A) string expression format, as in Msg=UZ(A).

For longer strings, you can use the String Array options of the Buf0-Buf7 Macro Arrays.

All macro and MIDI variables are global. This allows macros to pass information (such as between a Custom Controls macro and a multitasking macro), but it also requires that you specifically initialize variables... you can't depend upon them being zero by default.

However, Macro Arrays can be used to save and restore all floating-point and MIDI variables to preserve them during MIDI performances and multitasking macros, providing local variables when needed.


Floating-Point Macro Variables:

Macro variables A through Z are 80-bit floating-point real numbers with 64-bit precision (equivalent to about 18 digits) over a range from about 10^4932 down to 10^-4932.

Use these as working variables in math calculations. They are always cleared at the start of each Daqarta session.

To send A to a Remote Control client, use A=>> and A=>* to send the integer and fraction parts, respectively. (The float is automatically converted to fixed-point.) These will be sent as 32-bit lParam values, with 'intA' and 'frcA' as wParam identifiers.


Fixed-Point Macro Variables:

Macro variables Var0-Z are signed real numbers with 32-bit integer and 32-bit fraction parts, for 64-bit overall precision. The integer range is approximately +/-2 billion, while the fraction resolution is about 9 decimal places.

These variables are retained across Daqarta sessions.

Var0=x toggles Var0 between 0 and 1. If the initial value is zero the result is 1.00; otherwise the result is zero.

Note that Var0-Z macro variables are retained across sessions by default, independent of any .MAC file. You can use this property to set persistent macro preferences. But this also means you may need to explicitly clear some variables at the start of a session. For a single variable such as VarA, you can just use VarA=0. The VarClr command allows you to clear a range of variables, or all variables:

VarClr=AD sets VarA through VarD to zero.

VarClr= sets all variables Var0 through VarZ to zero.

There are no analogous clear commands for clearing a range of floating-point variables A-Z. They all default to 0 at the start of each session. Likewise, all elements in macro arrays Buf0-Buf7 default to zero. However, you can set all 1024 elements in any BufN array to zero via BufN="<=(0)". (You can use any value you choose. See Macro Array Copy/Swap Operations.)

To send VarA to a Remote Control client, use VarA=>> and VarA=>* to send the integer and fraction parts, respectively. These will be sent as 32-bit lParam values, with 'VarA' and 'varA' as wParam identifiers.

You can preset Fields to display Var0-Z macro variables (but not A-Z) when they are changed. For example Field1=?VarN will cause the value of VarN to be shown in Field 1 whenever VarN is modified. Use VarN=>0 to force the Field to show the current value without changing it.


Fixed-Point Example - Operator Prompts:

Suppose you have a complicated test suite, all run by macros, and want to provide a series of prompt messages to help train new operators. You can use VarA to tell if the prompts will be shown, so that they can be turned off when they are not needed. A macro called PromptTog will simply toggle VarA:

VarA=x.

A macro called _Prompt will be called at various points in the test sequence, indicating what to do next. Each stage of the series will be run by its own macro, which will set VarB to a unique value before calling the _Prompt macro via @_Prompt.

The _Prompt macro will test VarA and show no message if VarA is zero. Otherwise, it will test VarB and show the appropriate message.

    IF.VarA=0
        Msg=
    ELSE.
        IF.VarB=0
            Msg="Hit Test1 to start 1st test."
        ENDIF.
        IF.VarB=1
            Msg="Hit Stop1 to halt 1st test."
        ENDIF.
        IF.VarB=2
            Msg="Hit Save1 to save Test1 results."
        ENDIF.
        IF.VarB=3
            Msg="Hit Test2 to start 2nd test."
        ENDIF.
    ENDIF.

Fixed-Point Example - File Name Auto-Increment:

If your test suite saves a lot of different files that are all derived from the same subject or device under test, you will probably want to use the Auto-Increment Filenames option. You need to provide an initial base name for the first file saved, but not for subsequent saves which will append an incrementing value to the base name.

The initial setup macro (typically the '!' automatic startup macro) can prompt the operator to enter a subject ID to a Field before starting the test, by including the following commands:

    C=0
    Msg="Enter Subject ID"
    WaitChange=Field5
    Msg=

You may want to precede this by a MsgPosFix command set to show the Msg right over Field5.

The contents of Field5 (such as "Rat123") can then be used as the base file name. The following file save macro uses variable C as a flag, so that the base name will only be entered on the first save of the session:

    AutoInc=1
    IF.C=0
        A.SaveDQA=Field5
        C=1
    ELSE.
        A.SaveDQA=
    ENDIF.

The first time this is run in any session, it will save Rat123-000.DQA (or whatever name was entered instead of "Rat123") and set C to 1. The next time, it will save Rat123-001.DQA, incrementing on each subsequent save. (The A. prefix means that SaveDQA won't show a Save As dialog, it will just save the file directly.)

The fact that C starts out at zero insures that the initial save always sets the subject ID as the base name. Simple variables A-Z are automatically set to zero when Daqarta starts, so it isn't strictly necessary to set C to zero when the subject ID is entered, but this allows for cases when multiple subjects are tested in one session.


Fixed-Point Example - Initial Msg Position:

Suppose you want to set a particular default position for a draggable Msg, but once the user drags it, that new position should be used in future sessions. You can use an IF statement like this:

    IF.VarD=12345
        ;Do nothing
    ELSE.
        MsgPos="100,200"
        VarD=12345
    ENDIF.

The first time the macro runs, VarD will be 0 so the position will be set. Later in this session or future sessions, VarD will be 12345 so the MsgPos will not be run. If you have different .MAC files for different applications, you can use specific values to tell which .MAC set ran last, to have different positions for each.


MIDI Variables Used in Macros:

As noted earlier, macros have access to all MIDI Changes Script User Variables. Besides using these with macros to control MIDI performances, you can use them as extra macro variables if you are not using MIDI. U0 through U9 and UA through UZ, as well as Q0-9 and QA-Z, are signed integers whose values may range from -2147483648 to +2147483647 (+/- 2^31).

Ua through Uz and Qa through Qz are unsigned fixed-point decimals with a range from 0 to 65535.9999.

Note that all MIDI variables are cleared when Pitch-to-MIDI is toggled on, or when any script or control changes are made that require it to be restarted. (But see Special Macro-MIDI Integer Variables, below.)

There will rarely be a need for the Ua-z or Qa-z fixed-point MIDI variables in macros, since they have only 32-bit resolution compared to the 64-bit resolution of A-Z floats or Var0-Z fixed-point macro variables.

But the integer MIDI variables are especially useful in macros as index values and loop counters, and any other place where you specifically want an integer result. They don't require an explicit conversion function like int() or cint(); any assignment to a MIDI integer is automatically converted via rounding.

Integer MIDI variables also stand out in macro listings due the U or Q prefix, and they allow you to have more total variables... handy if you are using the letters as mnemonics.

To send a MIDI integer such as UA to a Remote Control client, use UA=>>. This will be sent as a 32-bit lParam value, with 'MvUA' as the wParam identifier. This does not apply to fixed-point MIDI variables.


Special Macro-MIDI Integer Variables:

There are 10 integer variables that, unlike the above U- and Q-type User Variables, are not cleared at the start of each MIDI performance. These "special" integers can be set by main Daqarta macros before or during a performance, and the MIDI Changes script can read or set them at any time. They are a bit more awkward to use because they have different read and write commands, which are also different between the macro version and the Changes script version.

Miscellaneous macros Posn#0 to Posn#9 write the integers, and Posn?0 to Posn?9 read them.

Changes script commands ?0 to ?9 write these same variables, and they can be read as Miscellaneous Position read-only values m0 to m9.


Memory Arbs as Integer Variable Arrays:

Memory Arbs MemArb0 to MemArb7 can serve as arrays of integers in the range of +/-32767. These arrays can be in sizes of 1024, 2048, 4096, 8192, or 16384 values each. You refer to individual array elements by index, such as MemArb0[UA]=X to write value X to element UA of MemArb0, or X=MemArb0[123] * 2 to set X to twice the value of element 123.


See also Macro Overview

GO:

Questions? Comments? Contact us!

We respond to ALL inquiries, typically within 24 hrs.
INTERSTELLAR RESEARCH:
Over 30 Years of Innovative Instrumentation
© Copyright 2007 - 2017 by Interstellar Research
All rights reserved