Skip to main content
                     
As-Built As-Built - Revit As-Built - AutoCAD VirtuSurv - VirtuSurv 2018 As-Built - Modeler VirtuSurv - VirtuSurv 2019          
BuildIT BuildIT - Projector BuildIT - Construction BuildIT - Metrology              
CAM2 CAM2 - SmartInspect CAM2 - 2018 CAM2 - Measure 10 CAM2 - Measure Q CAM2 - Measure X CAM2 - Measure 3/4 CAM2 - AnthroCAM CAM2 - 2019 CAM2 - 2020  
Cobalt 3D Imager 3D Imager - Cobalt                  
Cobalt Design Cobalt Design - M Cobalt Design - S Cobalt Design - Dual              
Computers Computers - All Computers                  
FARO Aras 360 & CAD Zone FARO CAD Zone - Fire & Insurance FARO CAD Zone - Crime & Crash FARO CAD Zone - CZ Point Cloud FARO CAD Zone - First Look Pro FARO 360 - Reality FARO 360 - HD FARO 360 - Blitz FARO 360 - Genius    
FARO Zone present4D - present4D                  
FARO Zone 2D FARO Zone 2D - 2018 FARO Zone 2D - 2019 FARO Zone 2D - 2020              
FARO Zone 3D FARO Zone 3D - 2018 FARO Zone 3D - 2019 FARO Zone 3D - 2020 FARO Zone 3D - 2021            
FARO Zone 3D Advanced FARO Zone 3D Advanced - 2018 FARO Zone 3D Advanced - 2019 FARO Zone 3D Advanced - 2020 FARO Zone 3D Advanced - 2021            
FaroArm/ScanArm FaroArm/ScanArm - Quantum S FaroArm/ScanArm - Quantum M FaroArm/ScanArm - Quantum E FaroArm/ScanArm - Edge FaroArm/ScanArm - Fusion FaroArm/ScanArm - Prime FaroArm/ScanArm - Platinum FaroArm/ScanArm - Legacy Quantum FaroArm/ScanArm - Titanium FaroArm/ScanArm - Advantage
FaroArm/ScanArm FaroArm/ScanArm - Digital Template FaroArm/ScanArm - Gage                
Hand Held Scanner 2D Hand Held Scanner - ScanPlan 3D Hand Held Scanner - Freestyle3D 3D Hand Held Scanner - Freestyle3D X 3D Hand Held Scanner - Freestyle3D Objects 3D Hand Held Scanner - Freestyle 2          
Language Quality HT MT AT NT INT - Internal Sales - Internal Resources Sales - Order and Quote Sales - Product Info Sales - Sales Readiness Sales - Training
Language Quality CS - Procedures and Product Sales - Product Launch Sales - Promotions              
Languages Language - English Language - Japanese Language - German Language - Chinese Language - Spanish Language - Italian Language - Portuguese Language - French    
Laser Projector RayTracer - RayTracer Laser Projector - Tracer M Laser Projector - Tracer SI              
Laser Radar Imaging Laser Radar - VectorRI                  
Laser Scanner 3D Laser Scanner - Focus S 3D Laser Scanner - Focus M 3D Laser Scanner - Focus3D 3D Laser Scanner - Focus3D X 3D Laser Scanner - Focus3D X HDR 3D Laser Scanner - Focus3D S 3D Laser Scanner - Photon 3D Laser Scanner - Focus S Plus 3D Laser Scanner - Swift  
Laser Tracker Laser Tracker - Vantage Laser Tracker - ION Laser Tracker - Vantage S Laser Tracker - Si Laser Tracker - X Laser Tracker - Xi Laser Tracker - Vantage E Laser Tracker - Vantage S6 Laser Tracker - Vantage E6  
Legacy Gage Legacy Gage - Bluetooth Legacy Gage - Plus Legacy Gage - Standard Legacy Gage - Power            
Legacy Software Legacy Software - CAM2 Gage Legacy Software - Gage Software Legacy Software - Insight              
PointSense PointSense - Basic PointSense - Pro PointSense - Building PointSense - Plant PointSense - Heritage PointSense - Revit CAD Plugin - TachyCAD Building CAD Plugin - TachyCAD Archeology CAD Plugin - TachyCAD Interior CAD Plugin - PhoToPlan Basic
PointSense CAD Plugin - PhoToPlan CAD Plugin - PhoToPlan Pro CAD Plugin - PhoToPlan Ultimate CAD Plugin - DisToPlan CAD Plugin - MonuMap CAD Plugin - hylasFM CAD Plugin - VirtuSurv      
RevEng RevEng - RevEng                  
ScanArm ScanArm - Design ScanArm 2.0 ScanArm - Design ScanArm ScanArm - Forensic ScanArm ScanArm - Design ScanArm 2.5C            
SCENE SCENE - Capture and Process SCENE - WebShare Server and 2Go SCENE - WebShare 2Go App SCENE - 2018 SCENE - 7.x SCENE - 6.x SCENE - 5.x SCENE - 4.x SCENE - LT SCENE - 2019
SCENE SCENE - 2go App SCENE - 2020                
Serial FaroArm Serial FaroArm - Silver Serial FaroArm - Gold Serial FaroArm - Bronze              
Visual Inspect Visual Inspect - App Visual Inspect - CAD Translator                
WebShare WebShare - Enterprise WebShare - WebShare Cloud                

BuildIT

Projector

FARO® Knowledge Base

Setting Up and Using the RPC Server with BuildIT Projector

Overview

The RPC (Remote Procedure Call) server allows executing BuildIT commands remotely. Activating this functionality enables using the BuildIT remote control, a browser-based application that offers an interface for conducting inspection and projection workflows.

The functionality can also be leveraged when external systems such as PLCs (Programmable Logic Controllers) or other control systems require driving BuildIT and coordinate the execution of automated processes and measurements commands.

Enabling the RPC server

By default, the RPC server functionality is deactivated. It needs to be activated manually once, and will remain activated whenever launching BuildIT afterwards. To activate the RPC server:

  1. Open “File: Setting
  2. Go to the “Interface” category
  3. In the “HTTP Server” section, tick the “Enabled” option
  4. Click “OK
    RPCServer-Settings.png
  5. Set the appropriate permissions for the network on which you will communicate with the RPC server.
    RPCServer-Firewall.png

Using the BuildIT Remote Control

The BuildIT Remote Control is a web-based application that offers a convenient interface for conducting inspection and projection workflows. The remote control interfaces with BuildIT using the RPC server and provides a good overview of the capabilities of the framework. To access the remote control application see: Download and Installation Instructions for BuildIT Remote Control

Communicating with External Systems via the RPC Server

The RPC server can be accessed by clients other than the remote control. It can be leveraged for performing communication with PLCs and other control systems.

  • If the control system can communicate over WebSocket, it can communicate directly with the RPC server.
  • If the control system cannot communicate over WebSocket, we suggest setting up a “broker” or “proxy” application that would translate the inputs from the control system into WebSocket calls, and send back the responses from the RPC server to the control system.

Accessing the RPC Server Documentation

The available commands and expected syntax are available through a web page:

  1. In a web browser, go to http://localhost:34203/html/rpc_test.html (if needed, replace the digits with the port number defined in the settings).
  2. Hit the “Connect” button to connect to the WebSocket server.
  3. All commands are available from this page and can be tested through this interface.
  4. The full list of commands can be printed using the “rpc.dir()” command.
    RPCServer-Documentation.png

Expected Syntax

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

Typical usage

In general, the RPC server’s available functions and mechanisms encourage designs where the external system controls BuildIT, and BuildIT performs the requested actions and commands, and provides handshakes and feedback.

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 during the robot movement, before performing 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 would coordinate the necessary steps with BuildIT through calls to the RPC server.
RPCServer-Workflow-metrology.png

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 - In older versions, the exchange needs to be done via other means

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 by 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.
    RPCServer-workflow-projector.png

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.

Example Client (Python)

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"}}
"""