roboticstoolbox-python 1.3.0__cp313-cp313-win_amd64.whl

roboticstoolbox/backends/Dynamixel/dynamixel_io.py

@@ -0,0 +1,450 @@
+#!/usr/bin/env python
+
+
+import time
+from pathlib import Path
+import dynamixel_sdk as sdk  # Uses Dynamixel SDK library
+
+# list of all models https://emanual.robotis.com/docs/en/software/dynamixel/dynamixel_workbench/
+
+# AX entry level
+# XL improved control
+# XM, XH better control, XH has Maxon motor
+import json
+
+
+class DynamixelString:
+    def __init__(self, baudrate=1000000, port=None, protocol=1, top=256, verbose=True):
+
+        jsonfile = Path(__file__).parent / "dynamixel.json"
+        print(jsonfile)
+        # load the JSON file and convert keys from strings to ints
+        with jsonfile.open() as f:
+            self.modeldict = {}
+            for key, value in json.load(f).items():
+                self.modeldict[int(key)] = value
+
+        # setup the serial port
+        # Initialize PortHandler instance
+        # Set the port path
+        # Get methods and members of PortHandlerLinux or PortHandlerWindows
+        self.port = sdk.PortHandler(port)
+
+        self.verbose = verbose
+
+        # Open port
+        if self.port.openPort():
+            print("Succeeded to open the port")
+        else:
+            print("unable to open serial port", port)
+            self.port = None
+            raise RuntimeError("Failed to open the port")
+
+        # Set port baudrate
+        if self.port.setBaudRate(baudrate):
+            print("Succeeded to change the baudrate")
+        else:
+            raise RuntimeError("Failed to change the baudrate")
+
+        # Initialize PacketHandler instance
+        # Set the protocol version
+        # Get methods and members of Protocol1PacketHandler or Protocol2PacketHandler
+        if protocol == 1:
+            self.packetHandler = sdk.PacketHandler("1.0")
+        else:
+            self.packetHandler = sdk.PacketHandler("2.0")
+
+        # X-series memory map
+        self.address = {}
+        self.address["model"] = (2, 4)
+        self.address["firmware"] = (6, 1)
+        self.address["return_delay"] = (9, 1)
+        self.address["drivemode"] = (10, 1, self._drivemode_handler)
+        self.address["opmode"] = (11, 1, self._opmode_handler)
+        self.address["shadow_id"] = (12, 1)
+
+        self.address["min_position"] = (52, 4)
+        self.address["max_position"] = (48, 4)
+        self.address["velocity_limit"] = (44, 4)
+
+        self.address["torque_enable"] = (64, 1)
+        self.address["hardware_error_status"] = (70, 1)
+
+        self.address["goal_position"] = (116, 4)
+        self.address["goal_velocity"] = (104, 4)
+        self.address["goal_pwm"] = (100, 2)
+
+        self.address["present_position"] = (132, 4)
+        self.address["present_position2"] = (132, 2)
+        self.address["present_current"] = (126, 2)
+        self.address["present_velocity"] = (128, 2)
+
+        self.address["profile_velocity"] = (112, 4)
+        self.address["profile_acceleration"] = (108, 4)
+
+        self.address["temp"] = (146, 1)
+        self.address["led"] = (65, 1)
+
+        self.idlist = []
+        self.models = {}
+
+        # poll the ports
+        for id in range(0, top):
+            model = self.ping(id)
+            if model > 0:
+                self.idlist.append(id)
+                self.models[id] = model
+                self.set(id, "torque_enable", False)
+                self.set(id, "led", False)
+        print("servos found", self.idlist)
+
+        error = self.get("all", "hardware_error_status")
+        if any(error):
+            print("hardware error", error)
+
+    def close(self):
+        self.port.closePort()
+
+    @property
+    def n(self):
+        return len(self.idlist)
+
+    def ping(self, id):
+        model_number, result, error = self.packetHandler.ping(self.port, id)
+        return model_number
+
+    def modelname(self, id):
+        mn = self.models[id]
+        try:
+            return self.modeldict[mn]["model"]
+        except KeyError:
+            return "?? mn={}".format(mn)
+
+    def list(self):
+        for id in self.idlist:
+            fw = self.get(id, "firmware")
+            print("{:2d} {:3d} {:s}".format(id, fw, self.modelname(id)))
+
+    def enable(self, on, id="all"):
+        # enable(True)  # all enabled
+        # enable (True, 1) # 1 is enabled
+        # enable(True, [1, 2])  # 1, 2 are enabled
+        # enable([True, False], [1, 2])  # 1 is enabled, 2 is disabled
+        # enable([True, True, False, False]) # 1,2 enabled, 3,4 disabled
+        if id == "all":
+            id = self.idlist
+        if isinstance(id, list):
+            if isinstance(on, bool):
+                for id in self.idlist:
+                    self.register_write(id, "torque_enable", on)
+            else:
+                assert len(on) == len(id), "incorrect enable flags"
+                for i in id:
+                    assert id in self.idlist, "invalid id"
+                    self.register_write(id, "torque_enable", on[i])
+        else:
+            assert id in self.idlist, "invalid id"
+            self.register_write(id, "torque_enable", on)
+
+    def ismoving(self, id):
+        return 0
+
+    def setposition(self, id, pos):
+        if id is None:
+            # TODO allow numpy array, use argcheck.getvector
+            assert (
+                isinstance(pos, (int, float))
+                or instance(pos, list)
+                and len(pos) == self.n
+            ), "incorrect position value"
+            for id in self.idlist:
+                self.register_write(id, "goal_position", pos[i])
+        else:
+            assert id in self.idlist, "invalid id"
+            self.register_write(id, "goal_position", pos)
+
+    def getposition(self, id="all"):
+        return self._getvalue("present_position", id)
+
+    def _opmode_handler(self, op, id, register, value=None):
+        dict = {1: "velocity", 3: "position", 4: "xposition", 16: "pwm"}
+
+        if op == "get":
+            x = self.register_read(id, register)
+            return dict[x]
+        elif op == "set":
+            for k, v in dict.items():
+                if v == value:
+                    self.register_write(id, register, k)
+
+    # for setting: handler(self, 'set', id, register, newvalue) -> value to write to register
+    # for getting: handler(self, 'get', id, register) -> value to return
+    def _drivemode_handler(self, op, id, register, value=None):
+        if op == "get":
+            x = self.register_read(id, register)
+            r = []
+            if (x & 1) == 1:
+                r.append("reverse")
+            elif (x & 1) == 0:
+                r.append("forward")
+            elif (x & 4) == 4:
+                r.append("tprofile")
+            elif (x & 4) == 0:
+                r.append("vprofile")
+            return r
+        elif op == "set":
+            curval = self.register_read(id, register)
+            if value == "reverse":
+                curval |= 1
+            elif value == "forward":
+                curval &= ~1
+            elif value == "tprofile":
+                curval |= 4
+            elif value == "vprofile":
+                curval &= ~4
+            self.register_write(id, register, curval)
+
+    # simple i/o using separate servo transations
+    def get(self, id, register):
+        if len(self.address[register]) > 2:
+            reader = lambda id, register: self.address[register][2]("get", id, register)
+        else:
+            reader = self.register_read
+        if id == "all":
+            id = self.idlist
+
+        if isinstance(id, list):
+            value = []
+            for i in id:
+                assert i in self.idlist, "invalid id"
+                value.append(reader(i, register))
+            return value
+        else:
+            assert id in self.idlist, "invalid id"
+            return reader(id, register)
+
+    def set(self, id, register, value):
+        if self.verbose:
+            print(f"set id={id}; {register} := {value}")
+
+        if len(self.address[register]) > 2:
+            writer = lambda id, register, value: self.address[register][2](
+                "set", id, register, value
+            )
+        else:
+            writer = self.register_write
+        if id == "all":
+            id = self.idlist
+        if isinstance(id, list):
+            if isinstance(value, list):
+                assert len(value) == len(id), (
+                    "length of value list must match number of servos"
+                )
+                for i, v in zip(id, value):
+                    assert i in self.idlist, "invalid id"
+                    writer(i, register, v)
+            else:
+                for i in id:
+                    writer(i, register, value)
+        else:
+            assert id in self.idlist, "invalid id %d" % (id,)
+            writer(id, register, value)
+
+    # wrapper on the Dynamixel SDK
+    def register_read(self, id, regname):
+        address, nbytes = self.address[regname][0:2]
+        if nbytes == 1:
+            dxl_value, dxl_comm_result, dxl_error = self.packetHandler.read1ByteTxRx(
+                self.port, id, address
+            )
+        elif nbytes == 2:
+            dxl_value, dxl_comm_result, dxl_error = self.packetHandler.read2ByteTxRx(
+                self.port, id, address
+            )
+        elif nbytes == 4:
+            dxl_value, dxl_comm_result, dxl_error = self.packetHandler.read4ByteTxRx(
+                self.port, id, address
+            )
+
+        if dxl_comm_result != sdk.COMM_SUCCESS:
+            raise RuntimeError(
+                self.packetHandler.getTxRxResult(dxl_comm_result)
+                + " id={}, register={}".format(id, regname)
+            )
+        elif dxl_error != 0:
+            raise RuntimeError(
+                self.packetHandler.getRxPacketError(dxl_error)
+                + " id={}, register={}".format(id, regname)
+            )
+        return dxl_value
+
+    def register_write(self, id, regname, value):
+        # print('register_write', id, regname, value)
+        if isinstance(regname, str):
+            address, nbytes = self.address[regname][0:2]
+        elif isinstance(regname, tuple) and len(regname) == 2:
+            address, nbytes = regname
+        else:
+            raise ValueError("register must be a string or (address, length) tuple")
+        if nbytes == 1:
+            dxl_comm_result, dxl_error = self.packetHandler.write1ByteTxRx(
+                self.port, id, address, value
+            )
+        elif nbytes == 2:
+            dxl_comm_result, dxl_error = self.packetHandler.write2ByteTxRx(
+                self.port, id, address, value
+            )
+        elif nbytes == 4:
+            dxl_comm_result, dxl_error = self.packetHandler.write4ByteTxRx(
+                self.port, id, address, value
+            )
+
+        if dxl_comm_result != sdk.COMM_SUCCESS:
+            raise RuntimeError(
+                self.packetHandler.getTxRxResult(dxl_comm_result)
+                + " id={}, register={}".format(id, regname)
+            )
+        elif dxl_error != 0:
+            raise RuntimeError(
+                self.packetHandler.getRxPacketError(dxl_error)
+                + " id={}, register={}".format(id, regname)
+            )
+
+    def register_indirect_config(self, id, indirectbase, regnames):
+        iaddr = (indirectbase - 1) * 2 + 168
+        count = 0
+
+        for regname in regnames:
+            address, nbytes = self.address[regname]
+            for i in range(0, nbytes):
+                self.register_write(id, (iaddr + i * 2, 2), address + i)
+                print(id, address + i, " --> ", iaddr + i * 2)
+
+            iaddr += 2 * nbytes
+            count += nbytes
+
+        return ((indirectbase - 1) + 224, count)
+
+    def register_read_sync(self, id, addrlen):
+        # create an indirect table, keep track of how many bytes to be read
+        groupSyncRead = GroupSyncRead(
+            self.port, self.packetHandler, addrlen[0], addrlen[1]
+        )
+        for id in self.active:
+            dxl_addparam_result = groupSyncRead.addParam(id)
+            if dxl_addparam_result != True:
+                pass  # bad thing
+
+    def pulseleds(self, nblinks=4, dt=0.1):
+        for i in range(0, nblinks):
+            self.set("all", "led", False)
+            time.sleep(dt)
+            self.set("all", "led", True)
+            time.sleep(dt)
+
+
+class DynRobot:
+    def __init__(self, dynamixels, arm, gripper):
+        self.dynamixels = dynamixels
+        self.idlist = []
+
+        for motor in arm:
+            print(motor)
+            if isinstance(motor, int):
+                self.idlist.append(motor)
+            elif isinstance(motor, (tuple, list)) and len(motor) == 2:
+                self.idlist.append(motor[0])
+                if motor[1] < 0:
+                    # motor is reveresed
+                    second = -motor[1]
+                    self.dynamixels.set(second, "opmode", "reverse")
+                else:
+                    second = motor[1]
+                # second motor shadows the first
+                self.dynamixels.set(second, "shadow_id", motor[0])
+
+        self.q0 = self.dynamixels.get(self.idlist, "present_position")
+
+    class SyncIO:
+        pass
+
+    def syncread_config(self, regnames, indirectbase=1):
+        sr = SyncIO()  # lgtm [py/unused-local-variable]
+
+        for id in self.idlist:
+            (a, l) = d.register_indirect_config(
+                id, indirectbase, regnames
+            )  # lgtm [py/unused-local-variable]
+
+    def setmode(self, m):
+        self.dynamixels.set(self.idlist, "drivemode", m)
+
+    def moveto(self, q, t=2000, tacc=200, block=True):
+        self.dynamixels.set(self.idlist, "profile_velocity", int(t * 1000))
+        self.dynamixels.set(self.idlist, "profile_acceleration", int(tacc * 1000))
+        self.dynamixels.set(self.idlist, "goal_position", q)
+
+    def getpos(self):
+        pass
+
+    def syncwrite_config(self):
+        pass
+
+    def enable(self, on):
+        if on:
+            self.dynamixels.pulseleds()
+        self.dynamixels.set(self.idlist, "torque_enable", on)
+        if not on:
+            self.dynamixels.set("all", "led", False)
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Dynamixel interactive console")
+    parser.add_argument(
+        "--port",
+        "-p",
+        default="/dev/tty.usbserial-FT4NQ6ZP",
+        help="specify name of serial port",
+    )
+    parser.add_argument(
+        "--baudrate", "-b", type=int, default=1000000, help="serial baud rate"
+    )
+    parser.add_argument(
+        "--protocol", type=int, default=2, help="Dynamixel protocol level"
+    )
+    parser.add_argument(
+        "--scan",
+        type=int,
+        default=20,
+        help="Scan for Dynamixel ids 1 to this number inclusive",
+    )
+    args = parser.parse_args()
+
+    dms = DynamixelString(
+        port=args.port, baudrate=args.baudrate, protocol=args.protocol, top=args.scan
+    )
+    dms.set("all", "return_delay", 0)
+
+    # simple console-based command handler
+    while True:
+        cmd = input("dynamixel>>> ")
+        cmd = cmd.strip()
+        cmd = cmd.split(",")
+        if cmd[0] == "list":
+            dms.list()
+        elif cmd[0] == "read":
+            p = d.getposition()
+            print(p)
+        elif cmd[0] == "limp":
+            dms.enable(False)
+        elif cmd[0] == "hold":
+            dms.enable(True)
+        elif cmd[0] == "led":
+            status = int(cmd[1])
+            dms.setled(status > 0)
+        elif cmd[0] == "temp":
+            print(dms.gettemp())
+        elif cmd[0] == "quit" or cmd[0] == "exit":
+            break

roboticstoolbox/backends/Dynamixel/dynamixel_sdk/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

roboticstoolbox/backends/Dynamixel/dynamixel_sdk/README.md

@@ -0,0 +1,28 @@
+<img src="http://emanual.robotis.com/assets/images/sw/sdk/dynamixel_sdk/overview/dynamixel_sdk_concept_logo.jpg">
+
+## Dynamixel SDK
+The ROBOTIS Dynamixel SDK is a software development kit that provides Dynamixel control functions using packet communication. The API is designed for Dynamixel actuators and Dynamixel-based platforms. For more information on Dynamixel SDK, please refer to the e-manual below.
+- [ROBOTIS e-Manual for Dynamixel SDK](http://emanual.robotis.com/docs/en/software/dynamixel/dynamixel_sdk/overview/)
+
+## Supported Programming Languages
+DynamixelSDK supports various programming languages.
+- **C**: *Dynamic library and source code of this library and examples
+- **C#** / **Java** / **MATLAB** / **LabVIEW**: Support based on dynamic library using C language
+- **C++**: *Dynamic library and source code of this library and examples
+- **Python**: Python module and examples
+(* Dynamic library (*.dll, *.so, and *.dylib files) / .dll: dynamic-link library on Windows / .so: shared object on Linux / .dylib: dynamic library on MacOS)
+
+## ROS 1 Packages for Dynamixel SDK
+|develop|master|Indigo + Ubuntu Trusty|Kinetic + Ubuntu Xenial|Melodic + Ubuntu Bionic|Noetic + Ubuntu Focal|
+|:---:|:---:|:---:|:---:|:---:|:---:|
+|[![Build Status](https://travis-ci.org/ROBOTIS-GIT/DynamixelSDK.svg?branch=develop)](https://travis-ci.org/ROBOTIS-GIT/DynamixelSDK)|[![Build Status](https://travis-ci.org/ROBOTIS-GIT/DynamixelSDK.svg?branch=master)](https://travis-ci.org/ROBOTIS-GIT/DynamixelSDK)|[![Build Status](https://travis-ci.org/ROBOTIS-GIT/DynamixelSDK.svg?branch=indigo-devel)](https://travis-ci.org/ROBOTIS-GIT/DynamixelSDK)|[![Build Status](https://travis-ci.org/ROBOTIS-GIT/DynamixelSDK.svg?branch=kinetic-devel)](https://travis-ci.org/ROBOTIS-GIT/DynamixelSDK)|[![Build Status](https://travis-ci.org/ROBOTIS-GIT/DynamixelSDK.svg?branch=melodic-devel)](https://travis-ci.org/ROBOTIS-GIT/DynamixelSDK)|[![Build Status](https://travis-ci.org/ROBOTIS-GIT/DynamixelSDK.svg?branch=noetic-devel)](https://travis-ci.org/ROBOTIS-GIT/DynamixelSDK)|
+
+## ROS 2 Packages for Dynamixel SDK
+|ros2-devel|ros2|Dashing + Ubuntu Bionic|Eloquent + Ubuntu Bionic|Foxy + Ubuntu Foxy|
+|:---:|:---:|:---:|:---:|:---:|
+|[![Build Status](https://travis-ci.org/ROBOTIS-GIT/DynamixelSDK.svg?branch=ros2-devel)](https://travis-ci.org/ROBOTIS-GIT/DynamixelSDK)|[![Build Status](https://travis-ci.org/ROBOTIS-GIT/DynamixelSDK.svg?branch=ros2)](https://travis-ci.org/ROBOTIS-GIT/DynamixelSDK)|[![Build Status](https://travis-ci.org/ROBOTIS-GIT/DynamixelSDK.svg?branch=dashing-devel)](https://travis-ci.org/ROBOTIS-GIT/DynamixelSDK)|[![Build Status](https://travis-ci.org/ROBOTIS-GIT/DynamixelSDK.svg?branch=eloquent-devel)](https://travis-ci.org/ROBOTIS-GIT/DynamixelSDK)|[![Build Status](https://travis-ci.org/ROBOTIS-GIT/DynamixelSDK.svg?branch=foxy-devel)](https://travis-ci.org/ROBOTIS-GIT/DynamixelSDK)|
+
+For more information on ROS Packages for Dynamixel SDK, please refer to the ROS wiki pages below.
+- http://wiki.ros.org/dynamixel_sdk
+- http://wiki.ros.org/dynamixel_workbench
+- http://wiki.ros.org/dynamixel_workbench_msgs