Click or drag to resize

CommandListAppendCallList(Int32, UInt32, IOPort, Boolean, Boolean, UInt32) Method

Conditionally call to the specified list.


Namespace: RAYLASE.SPICE3.ClientLib
Assembly: RAYLASE.SPICE3.ClientLib (in RAYLASE.SPICE3.ClientLib.dll) Version: 3.5.2
Syntax
C#
Copy
public void AppendCallList(
	int listID,
	uint cond,
	IOPort port,
	bool compareCondAsMask,
	bool ifNotTrue = false,
	uint mask = 4294967295
)

Parameters

listID  Int32
The target list identifier.
cond  UInt32
The condition mask. Note that how this value is matched against the I/O port value depends on the compareCondAsMask flag and on mask.
port  IOPort
The port which is queried to test the condition against.
compareCondAsMask  Boolean
false
cond value (cv) must exactly match the I/O port value (pv) read back from port at the time of execution.
Only the bits set in mask are compared.
The condition evaluates to true if (cv & mask) == (pv & mask).
true
cond value (cv) itself is applied as a bit mask to the I/O port value (pv) read back from port at the time of execution.

The condition evaluates to true if (cv & pv) != 0.

ifNotTrue  Boolean  (Optional)
false (default)
the call is executed if the condition evaluates to true
true
the call is executed if the condition evaluates to false.
mask  UInt32  (Optional)
This is only used when compareCondAsMask is set to false. Only the bits set to 1 in mask are compared. All bits set to 0 are ignored.
Remarks

Appends a CALL_LIST_COND command to the list.

The target list is executed as a sublist. Once, the target list has finished the calling list will resume execution.

The calling list remains busy during the execution of the target list. Once all of the calling list's commands have been processed, it will become idle and as a result trigger a ListIdle event.

For every Execute(Int32) only one ListDone event will be sent along with the list ID of the final main list, i.e. a list that has not been called by any other list(s). Lists that are called by other lists do not produce any ListDone events. However, sub lists do produce ListIdle events.

Caution note  Caution

Conditional CALL commands do NOT automatically de-activate the laser.

See also: 12.9 Notes on Flow-Control Commands.

Example
Common CallList and BranchList Command Examples
Copy
int sublistID = 333;

uint bitmask = 0x5AA5;

string varname = "var";

CommandList list = new CommandList();
list.AppendJumpAbs( 0, 0 );
list.AppendMarkAbs( 500, 500 );
list.AppendJumpAbs( 100, 200 );

// Append a CallList or BranchList command at the end of the main list:
for ( int i = 0; i < 6; i++ )
{
    switch ( i )
    {
        case 0:
            list.AppendCallList( sublistID ); // Unconditional
            break;

        case 1:
            list.AppendCallList( sublistID, bitmask, IOPort.PortB, true ); // Conditional on value read from port.
            break;

        case 2:
            list.AppendCallList( sublistID, varname ); // Conditional on value of the boolean variable on the card.
            break;

        case 3:
            list.AppendBranchList( sublistID ); // Unconditional
            break;

        case 4:
            list.AppendBranchList( sublistID, bitmask, IOPort.PortB, true ); // Conditional on value read from port.
            break;

        case 5:
            list.AppendBranchList( sublistID, varname ); // Conditional on value of the boolean variable on the card.
            break;

        default:
            break;
    };

    Console.WriteLine( $"{i + 1}: list commands:" );
    int count = 0;
    foreach ( var cmd in list )
        if ( count < ( list.Count - 2 ) )
            Console.Write( $" {count++}: {cmd.ToString()} " );
        else
            Console.WriteLine( $" {count++}: {cmd.ToString()}" );

    list.RemoveAt( list.Count - 1 ); // we're going to replace the call or branch command, but re-use the rest of the list
};

// output should be:
// 1: list commands:
//  0: { JA, P2D[ X=0 Y=0 ] }  1: { MA, P2D[ X=500 Y=500 ] }  2: { JA, P2D[ X=100 Y=200 ] }
//  3: { CL, I32[ 333 ] }
// 2: list commands:
//  0: { JA, P2D[ X=0 Y=0 ] }  1: { MA, P2D[ X=500 Y=500 ] }  2: { JA, P2D[ X=100 Y=200 ] }
//  3: { CLC, I32[ 333 ], U32[ 23205 ], I32[ 1 ], Bool[ False ], Bool[ True ], U32[ 4294967295 ] }
// 3: list commands:
//  0: { JA, P2D[ X=0 Y=0 ] }  1: { MA, P2D[ X=500 Y=500 ] }  2: { JA, P2D[ X=100 Y=200 ] }
//  3: { CLCF, I32[ 333 ], U32[ 2317739966 ], Bool[ False ] }
// 4: list commands:
//  0: { JA, P2D[ X=0 Y=0 ] }  1: { MA, P2D[ X=500 Y=500 ] }  2: { JA, P2D[ X=100 Y=200 ] }
//  3: { BRL, I32[ 333 ] }
// 5: list commands:
//  0: { JA, P2D[ X=0 Y=0 ] }  1: { MA, P2D[ X=500 Y=500 ] }  2: { JA, P2D[ X=100 Y=200 ] }
//  3: { BRLC, I32[ 333 ], U32[ 23205 ], I32[ 1 ], Bool[ False ], Bool[ True ], U32[ 4294967295 ] }
// 6: list commands:
//  0: { JA, P2D[ X=0 Y=0 ] }  1: { MA, P2D[ X=500 Y=500 ] }  2: { JA, P2D[ X=100 Y=200 ] }
//  3: { BRLCF, I32[ 333 ], U32[ 2317739966 ], Bool[ False ] }
See Also