Param Set Table V3

The Param Set Table V3 module writes the values of one column of a statically defined table to an internal array of another module. A common use case is to update the coefficients of an FIR module based on changing conditions in the system.

The numDim variable determines the dimensions of the table to be stored. The numCols variable determines the number of vectors that can be stored in the internal table. The numRows variable determines the length of each vector.

It is the responsibility of the user to ensure that the numRows variable matches the size of the target module's array. The integer value of the input pin is used to select which column to copy to the target module's array.

The array values are stored in a non-interleaved way, e.g. numDims=2,numRows=3,numCols=4 aaabbb aaabbb aaabbb aaabbb.

If numDim and numRows are all = 1 then the module will assume a scalar value to write.

See the Param Set module documentation for more detail on how to specify the target module's array, and the meaning of each setBehavior type.

For AWE gurus: Functionality in Param Set Table V3 can also be achieved with combining the Array Set and Table Source V2 modules for multi-dim tables or Param Set modules for scalar variables. But Param Set Table V3 adds more convenience, e.g. it supports writing into scalar values (not arrays only), Array Set by itself does not support "OnChangeSet" behavior, hence fewer number of modules in total will be required.

The argument executionOrder determines when the param set table v3 will actually execute in relation to the module it is controlling:

Undefined = Let the build process decide

Before = Set the parameter before the target module executes

After = Set the parameter after the target module executes

This can be confirmed by generating a .AWS file and looking at the order which the modules are added to the layout, which set the execution order.

OnChangeBehavior: This ParamSetTable module updates the target module's array in case a) table array contents change (during run-time) b) index value on the input pin changes

This is the v3 version of this module and it uses the correct mask value when calling the controlled module's Set() function. Plus it supports complex data and setBehavior enum has been extended with 'AlwaysInstantSet'.

Module Pack

Advanced

ClassID

classID = 1456

Type Definition

typedef struct _ModuleParamSetTableV3
{
ModuleInstanceDescriptor instance;            // Common Audio Weaver module instance structure
INT32 index;                                  // Current index to table array
INT32 setBehavior;                            // Controls the behavior of the module
INT32 numDim;                                 // The number of dimensions of the array
INT32 numRows;                                // The size of each vector
INT32 numCols;                                // The number of vectors
INT32 isComplex;                              // Is complex or not
INT32 tableHeap;                              // Heap in which to allocate memory
UINT32 mask;                                  // MASK value when calling the controlled module's set function
FLOAT32* table;                               // Array table (numDim*numRows, numCols)
void * modPtr;                                // Points to the module to set
void * varPtr;                                // Points to the variable to set within the module instance structure
} ModuleParamSetTableV3Class;

Variables

Properties

Name	Type	Usage	isHidden	Default Value	Range
index	int	parameter	0	-1	Unrestricted
setBehavior	int	parameter	0	3	Unrestricted
numDim	int	const	0	1	Unrestricted
numRows	int	const	0	2	Unrestricted
numCols	int	const	0	5	Unrestricted
isComplex	int	const	0	0	Unrestricted
tableHeap	int	const	0	2	Unrestricted
mask	uint	derived	1	0	Unrestricted
table	float*	parameter	0	[2 x 5]	Unrestricted
modPtr	void *	parameter	1		Unrestricted
varPtr	void *	parameter	1		Unrestricted

Pins

Input Pins


Name	in
Description	array index
Data type	int
Channel range	1
Block size range	Unrestricted
Sample rate range	Unrestricted
Complex support	Real

Matlab Usage

File Name: param_set_table_v3_module.m 
 M = param_set_table_v3_module(NAME, DATATYPE, NUMDIM, NUMROWS, NUMCOLS, ISCOMPLEX, MODVAR, EXECUTIONORDER, MEMHEAP) 
 Param table set module. This module can reach into the instance structure 
 of other modules and set array values.   
 Arguments: 
    NAME           - name of the module. 
    DATATYPE       - string specifying the data type of the variable and this 
                     is also used for the data type of the input pin. Allowable 
                     values are 'float', 'fract32' and 'int'. 
    NUMDIM         - number of table dimensions 
    NUMROWS        - size of one (1-d) table 
    NUMCOLS        - number of presets 
    ISCOMPLEX      - Boolean indicating whether the table data is complex. 
                     By default, ISCOMPLEX = 0 
    MODVAR         - specifies the module and variable name using the form: 
                     'MOD.VAR' where MOD is the module name and VAR is the  
                     variable name.  You can also specify internal subsystems using 
                     'SUBSYS.MOD.VAR'. 
    EXECUTIONORDER - Determines when the ParamSet module executes relative 
                     to the module it is controlling.  Allowable values are: 
                     'undefined' - the default.  The execution order is set 
                                   by the routing algorithm and can occur before 
                                   or after the module it is controlling. 
                     'before' - forces ParamSet to execute before the module it 
                                is controlling. 
                     'after' - forces ParamSet to execute after the module it 
                                is controlling. 
                     When using 'before' and 'after' you could get a build error 
                     indicating that no more modules can execute or there is a  
                     circular dependency. 
    MEMHEAP        - specifies the memory heap to use to allocate the main 
                     state buffer. This is a string and follows the memory allocation 
                     enumeration in Framework.h. Allowable values are: 
                     'AWE_HEAP_FAST' - always use internal DM memory. 
                     'AWE_HEAP_FASTB' - always use internal PM memory. 
                     'AWE_HEAP_SLOW' - always use external memory. 
                     'AWE_HEAP_FAST2SLOW' - use internal memory. If this fails 
                     then use external memory (the default). 
                     'AWE_HEAP_FASTB2SLOW' - use internal memory. If this fails 
                     then use external memory.