0 Quick Start Guide

//////////////////////////////////////////////////////////////////////////
// 
// Mark a square on the XY plane,
// centered about the origin of the marking field.
// 
//////////////////////////////////////////////////////////////////////////
using RAYLASE.SPICE3;
using RAYLASE.SPICE3.ClientLib;
using System;

internal class SPICE3ClientProgram
{
    // 
    // TODO:
    // Substitute your SP-ICE-3 card's real IP address here:
    // 
    private static string CardIP = "192.168.1.1";

    private static void Main( string[] args )
    {
        //////////////////////////////////////////////////////////////////////////
        // 
        // Stage 1: Initialization.
        // 
        //////////////////////////////////////////////////////////////////////////

        // 
        // Instantiate the ClientAPI.
        // 
        using ( ClientAPI client = new ClientAPI() )
        {
            try
            {
                // Open a communications channel to the SP-ICE-3 card.
                client.Connect( CardIP );

                // Make sure the card initially uses default parameter values and settings.
                // These will normally be what you configured with
                // the SP-ICE-3 Config Tool (SPICE3Config.exe).
                client.System.ResetToDefaults();

                // Retrieve the card's current ScannerConfiguration,
                // so that we can extract some useful values
                // (such as the FieldSize, for instance).
                ScannerConfig sc = client.Scanner.GetConfig();

                // Work out a suitable size for the square we want to mark,
                // ensuring that it will fit within available marking field.
                double sizeX = ( 7 * sc.FieldSize.X ) / 8;
                double sizeY = ( 7 * sc.FieldSize.Y ) / 8;

                // Work out the extents of the square along both axes,
                // so that the square is centered on the field origin.
                double maxX = 0.5 * sizeX;
                double minX = -0.5 * sizeX;
                double maxY = 0.5 * sizeY;
                double minY = -0.5 * sizeY;

                // TODO:
                // Substitute values suitable for your system here.
                double markSpeed = 0.1;
                double jumpSpeed = 1.0;

                //////////////////////////////////////////////////////////////////////////
                // 
                // Stage 2: Command list preparation.
                // 
                //////////////////////////////////////////////////////////////////////////

                // Create a local Command List.
                CommandList list = new CommandList();

                // TODO:
                // Substitute process settings suitable for your system here.
                // Note: this list is not exhaustive: you may need more, as well as other, values.
                client.Laser.SetPowerScale( 1.0 );

                // TODO:
                // Substitute process parameter values suitable for your system here.
                // Note: this list is not exhaustive: you may need more, as well as other, values.
                // 
                // Append process parameter values to the List:
                list.AppendJumpSpeed( jumpSpeed );
                list.AppendMarkSpeed( markSpeed );
                list.AppendLmFrequency( 0.01 );
                list.AppendLmWidth( 75 );
                list.AppendPower( 32767 );

                // Append vectors to the List:
                list.AppendJumpAbs( minX, minY );
                list.AppendMarkAbs( maxX, minY );
                list.AppendMarkAbs( maxX, maxY );
                list.AppendMarkAbs( minX, maxY );
                list.AppendMarkAbs( minX, minY );
                list.AppendJumpAbs( 0, 0 );

                // Transfer the Command List to the SP-ICE-3 card.
                // NB: the remote List ID is arbitrary, but MUST be unique.
                int listID = 0;
                client.List.Set( listID, list );

                //////////////////////////////////////////////////////////////////////////
                // 
                // Stage 3: Command list execution and monitoring.
                // 
                //////////////////////////////////////////////////////////////////////////

                // Determine a suitable timeout value for the marking process.
                // 
                // For this example, we take the expected marking time (in milliseconds)
                // for the square, and add a couple of seconds leeway:
                int timeoutMs = (int)( 1e-3 * ( ( 2 * ( maxX - minX ) ) + ( 2 * ( maxY - minY ) ) ) / markSpeed ) + 2000;

                // Allow the SP-ICE-3 card to generate LM and Gate signals,
                // and activate the ArmLaser signal on Port D/E.
                client.Laser.ArmLaser( true );

                // Execute the Command List, and then...
                client.List.Execute( listID );

                // ... wait for notification from the card that it has finished processing the List.
                int? doneID;
                if ( !client.List.WaitForListDone( out doneID, timeoutMs ) )
                {
                    throw new ListException( "Timed out waiting for ListDone." );
                }
                if ( doneID != listID )
                {
                    throw new ListException( "Got ListDone for wrong listID!" );
                }
            }
            catch ( Exception ex )
            {
                //////////////////////////////////////////////////////////////////////////
                // 
                // Stage 4: Error handling.
                // 
                //////////////////////////////////////////////////////////////////////////

                // TODO:
                // Define suitable error handling for your application.
                Console.WriteLine( "Uhhh, Houston? We've had a problem...{0}", ex.ToString() );
            }
        }
    }
}