Setting Up and Using the RPC Server with BuildIT Projector

Example: Robot Path Validation with the Laser Tracker

In this application, the external controller (robot controller) and BuildIT need to coordinate and go through a robot path validation workflow. The robot starts at an arbitrary position, and BuildIT acquires data while the robot is moving. BuildIT then performs an analysis. The two systems need to exchange some information before and after the robot movement, and coordinate when to start and stop the acquisition.

During the execution of the process, the controller coordinates the necessary steps with BuildIT through calls to the RPC server.

In this example, the robot controller performs essentially 5 calls to the RPC server:

1. Set global BuildIT variables to be retrieved and used by the process
   • Available in BuildIT 2021 - In older versions, the exchange needs to be done via other means
2. Launch the process corresponding to the job to be performed
3. Launch the measurement when both the robot and BuildIT are ready
4. Stop and accept the measurement when the robot has completed its path
5. Retrieve the global BuildIT variables set by the process
   • Available in BuildIT 2021

For ensuring that BuildIT is ready to be issued those 5 calls (i.e. validating there is no process already running, knowing when the measurement command is ready, or confirm it has started, validating the process has finished, etc.) the robot controller can poll the BuildIT RPC server for getting the relevant measurement and process status.

Example: Projection Workflow

In this application, the external controller activates the projection layers pre-defined in the projection plan. Before starting the projection, the controller and BuildIT need to coordinate on a few preliminary steps.

The whole workflow consists of essentially 4 separate calls to the RPC server:

1. Opening the model.
   • This model contains the layers to be projected.
2. Connecting to the projectors in plan.
3. Aligning the projectors to retro-targets.
   • Those retro-targets are listed in the projection plan and their nominal positions are defined in the BuildIT model.
4. Activating the projection layers. This step would generally consist of a loop on the controller’s side. The BuildIT application does not require running any automated process for receiving those calls.
   
   

In cases where the projector or the part would be moving using an actuator, performing a dynamic relocation would require calling an automated BuildIT process for moving the projectors to the desired position in the BuildIT model. This step could be called via the RPC server at any point, just like the other steps in the workflow.

Expected Syntax when using WebSocket Interface

The RPC server expects a json string over WebSocket. This string should be comprised of the following properties:

• method: Name of the method to run - this name can be obtained via the documentation
• params: Arguments passed to the method * The definition of arguments can be obtained via the documentation * Methods that do not expect an argument should be passed the “null” parameter
• id: the id sent along with the request will be sent back with the response

That page lists the methods available in the API. Those RPC calls can be tested independently of Python in a web browser, via http://localhost:34203/rpc_test.html.

• Info on the active instances of BuildIT can also be visualized via http://localhost:34203/api/info
• A new instance of BuildIT can be launched by the service via http://localhost:34203/api/launch

Example WebSocket Client (written in Python)

Note: If writing the client application using Python, we strongly recommend using the Python API. The example below is meant to illustrate a typical WebSocket communication with the RPC server, and not for providing an example on writing a client application in Python.

Information on the Python API can be found in the internal documentation.

import json
import asyncio
import websockets

uri = "ws://localhost:34203/ws/buildit"

commands = [
    {
        'method' : 'buildit.getProfileName',
        'params' : None,
        'id'     :  1
        },
    {
        'method' : 'buildit.messageBarOutput',
        'params' : ['Sending a message via RPC server', 'normal'],
        'id'     :  2
        },
    {
        'method' : 'buildit.getProcessInfo',
        'params' : None,
        'id'     :  3
        }
    ]

async def send_messages():
    try:
        async with websockets.connect(uri) as websocket:
            for command in commands:
                message = json.dumps(command)
                await websocket.send(message)
                print(f"> {message}")
                response = await websocket.recv()
                print(f"< {response}")
    except OSError:
        print(f'Make sure BuildIT is connected and RPC server is running and listening at address {uri}')

asyncio.get_event_loop().run_until_complete(send_messages())

"""
Output:
> {"method": "buildit.getProfileName", "params": null, "id": 1}
< {"id":1,"result":"Metrology"}
> {"method": "buildit.messageBarOutput", "params": ["Sending a message via RPC server", "normal"], "id": 2}
< {"id":2,"result":null}
> {"method": "buildit.getProcessInfo", "params": null, "id": 3}
< {"id":3,"result":{"name":"","path":"","status":"STOP"}}
"""