DobotRPC 4.8.8

Dobotlink communication module

This version is relevant for Dobotlink 5.0.0 and python3.5+

DobotRPC is a dobotlink communication module based on websocket and JSON-RPC . It provides python ports to communicate with dobotlink and allows developers to communicate with the GUI.

APIS

• RPCClient: RPCClient is a class that allows users to instantiate their own client, which uses WebSocket protocol to connect to a target IP and port, and then uses JSON format for data communication.

  • set_ip: Version 4.7.4 or above is acceptable. The IP and port used to set the destination address.

• RPCServer: RPCServer is a class that allows users to instantiate their own server, which waits for a client to connect using the WebSocket protocol, and then uses JSON format for data communication. The default port number is 9091.

• loggers: Provide an instantiated loggers interface. The user can call the following interfaces to do the configuration.

  • set_filename: Set log file name.
  • set_level: Set the log output level.
  • set_use_console: Set log output to the console.
  • set_use_file: Set log output to a file.

• DobotlinkAdapter: Provides an adapter for DobotLink RPC communication.

• NormalAdapter: Provides an adapter for normal RPC communication

Examples

• Users can communicate synchronously or asynchronously.The asynchronous mode is as follows:

# Async demo
from DobotRPC import DobotlinkAdapter, RPCClient, loggers
# The asyncio module provides infrastructure for writing single-threaded concurrent code using coroutines, multiplexing I/O access over sockets and other resources, running network clients and servers, and other related primitives.
import asyncio


# Coroutines function
async def main(dobotlink_async):
    # Display information with Dobotlink
    await dobotlink_async.api.ShowMessage(title="Async Demo Message",
                                          message="Async Demo is running.")

    # Search for available ports
    res = await dobotlink_async.Magician.SearchDobot()

    # Get ports
    if len(res) < 1:
        return
    port_name = res[0]["portName"]

    # Connect
    await dobotlink_async.Magician.ConnectDobot(portName=port_name)

    # PTP
    await dobotlink_async.Magician.SetPTPCmd(portName=port_name,
                                             ptpMode=0,
                                             x=230,
                                             y=50,
                                             z=0,
                                             r=20)
    # Disconnect
    await dobotlink_async.Magician.DisconnectDobot(portName=port_name,
                                                   queueStop=True,
                                                   queueClear=True)


if __name__ == "__main__":
    loggers.set_level(loggers.DEBUG)
    # Get the Eventloop reference
    loop = asyncio.get_event_loop()
    # Initializes, connects to dobotlink, and is executed before the Loop runs
    dobotlink_async = DobotlinkAdapter(RPCClient(loop=loop), is_sync=False)
    # Perform coroutines
    loop.run_until_complete(main(dobotlink_async))

• The synchronization mode is as follows:

# Sync Demo
from DobotRPC import RPCClient, DobotlinkAdapter, loggers


def main(dobotlink_sync):
    # Display information with Dobotlink
    dobotlink_sync.api.ShowMessage(title="Sync Demo Message",
                                   message="Sync Demo is running.")

    # Search for available ports
    res = dobotlink_sync.Magician.SearchDobot()

    # Get ports
    if len(res) < 1:
        return
    port_name = res[0]["portName"]

    # Connect
    dobotlink_sync.Magician.ConnectDobot(portName=port_name)

    # PTP
    dobotlink_sync.Magician.SetPTPCmd(portName=port_name,
                                      ptpMode=0,
                                      x=230,
                                      y=50,
                                      z=0,
                                      r=20)

    # Disconnect
    dobotlink_sync.Magician.DisconnectDobot(portName=port_name)


if __name__ == "__main__":
    loggers.set_level(loggers.DEBUG)
    # Initialize, connect to dobotlink
    dobotlink_sync = DobotlinkAdapter(RPCClient(), is_sync=True)

    main(dobotlink_sync)

Installtion

To install DobotRPC, type:

pip install DobotRPC

DobotRPC is a free software distributed under the Apache license

Usage

• Users can use the API: loggers, RPCClient, DobotlinkAdapter, NetworkError, client, aip
• Install Dobotlink 32bit 64bit
• Right-click the Dobotlink icon and click help, pop up a Dobotlink help documentation.
• You can guide by examples, reference the Dobotlink help documentation.
• Then go ahead and develop your first python script.