Metadata-Version: 2.1
Name: DobotRPC
Version: 4.8.7
Summary: Dobotlink communication module
Home-page: UNKNOWN
Author: songlijun
Author-email: songlijun@dobot.cc
License: Apache Licence
Description: ***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:
        
        ```python
        
        # 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:
        
        ```python
        
        # 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:
        
        ```python
        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](https://cdn.dobotlab.dobot.cc/release/DobotLinkSetup_32.exe) [64bit](https://cdn.dobotlab.dobot.cc/release/DobotLinkSetup_64.exe)
        -  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.
Keywords: websocket,JSON-RPC,asyncio,Dobot,Dobotlink,Client,Server
Platform: any
Description-Content-Type: text/markdown
