def __init__(self,
dxl_id,
usb,
port_handler=None,
pt_lock=None,
verbose=False):
Device.__init__(self, verbose)
self.dxl_id = dxl_id
self.comm_errors = 0
#Make access to portHandler threadsafe
if pt_lock is None:
self.pt_lock = threading.RLock()
else:
self.pt_lock = pt_lock
self.usb = usb
#Allow sharing of port handler across multiple servos
self.packet_handler = None
try:
if port_handler is None:
self.port_handler = prh.PortHandler(usb)
self.port_handler.openPort()
self.port_handler.setBaudRate(57600)
else:
self.port_handler = port_handler
self.packet_handler = pch.PacketHandler(2.0)
except serial.SerialException as e:
print("SerialException({0}): {1}".format(e.errno, e.strerror))
self.hw_valid = self.packet_handler is not None
def identify_baud_rate(dxl_id, usb):
"""Identify the baud rate a Dynamixel servo is communicating at.
Parameters
----------
dxl_id : int
Dynamixel ID on chain. Must be [0, 25]
usb : str
the USB port, typically "/dev/something"
Returns
-------
int
the baud rate the Dynamixel is communicating at
"""
for b in BAUD_MAP.keys():
port_h = prh.PortHandler(usb)
port_h.openPort()
port_h.setBaudRate(b)
packet_h = pch.PacketHandler(2.0)
_, dxl_comm_result, _ = packet_h.ping(port_h, dxl_id)
port_h.closePort()
if dxl_comm_result == COMM_SUCCESS:
return b
return -1
def __init__(self,
port,
baudrate,
feedback_echo=False,
protocol_version=2.0):
# Initialize Port and Packet Handler, also make needed variables / objects
# TODO: Should try/catch in case of errors
self.serial_mutex = Lock()
self.port_handler = port_h.PortHandler(port)
self.packet_handler = packet_h.PacketHandler(protocol_version)
self.port_handler.openPort()
self.port_handler.setBaudRate(baudrate)
self.port = port
self.baudrate = baudrate
self.dynotools = dynamixel_tools.DynamixelTools()
self.raw_to_deg_switch = {
'54024': self.raw_to_deg_pulse,
'311': self.raw_to_deg_static,
'1120': self.raw_to_deg_static,
'1020': self.raw_to_deg_static
}
self.deg_to_raw_switch = {
'54024': self.deg_to_raw_pulse,
'311': self.deg_to_raw_static,
'1120': self.deg_to_raw_static,
'1020': self.deg_to_raw_static
}
def __init__(self,
dxl_id,
usb,
port_handler=None,
pt_lock=None,
baud=57600,
logger=logging.getLogger()):
self.dxl_id = dxl_id
self.usb = usb
self.comm_errors = 0
self.last_comm_success = True
self.logger = logger
# Make access to portHandler threadsafe
self.pt_lock = threading.RLock() if pt_lock is None else pt_lock
# Allow sharing of port handler across multiple servos
self.packet_handler = None
try:
if port_handler is None:
self.port_handler = prh.PortHandler(usb)
self.port_handler.openPort()
self.port_handler.setBaudRate(baud)
else:
self.port_handler = port_handler
self.packet_handler = pch.PacketHandler(2.0)
except serial.SerialException as e:
self.logger.error("SerialException({0}): {1}".format(
e.errno, e.strerror))
self.hw_valid = self.packet_handler is not None
def get_feedback(self, servo_id):
# Port and packet handler set up
self.port_handler = port_h.PortHandler(self.port_name)
self.packet_handler = packet_h.PacketHandler(self.protocol_version)
# Set up port and baud rate
self.port_handler.openPort()
self.port_handler.setBaudRate(self.baud_rate)
return self.sdk_io.get_feedback(servo_id, self.motor_info)
def __init__(self, dxl_id, device_name, baudrate=4000000):
self.DXL_ID = dxl_id
self.BAUDRATE = baudrate
self.DEVICENAME = device_name
self.PROTOCOL_VERSION = 2.0
self.ADDR_OPERATING_MODE = 11 # 1 Byte
self.ADDR_OPERATING_MODE_LENGTH = 1 # 1 Byte
self.ADDR_PRO_TORQUE_ENABLE = 64 # Control table address is different in Dynamixel model # 1 Byte
self.ADDR_PRO_TORQUE_ENABLE_LENGTH = 1
self.ADDR_PRO_GOAL_POSITION = 116 # 4 Bytes
self.ADDR_PRO_GOAL_POSITION_LENGTH = 4
self.ADDR_PRO_PRESENT_POSITION = 132 # 4 Bytes
self.ADDR_PRO_PRESENT_POSITION_LENGTH = 4
self.ADDR_PRO_GOAL_CURRENT = 102 # 2 Bytes
self.ADDR_PRO_GOAL_CURRENT_LENGTH = 2
self.ADDR_PRO_PRESENT_CURRENT = 126 # 2 Bytes
self.ADDR_PRO_PRESENT_CURRENT_LENGTH = 2
self.ADDR_PRO_PRESENT_VELOCITY = 128 # 4 Bytes
self.ADDR_PRO_PRESENT_VELOCITY_LENGTH = 4
self.ADDR_PRO_GOAL_VELOCITY = 104 # 4 Bytes
self.ADDR_PRO_GOAL_VELOCITY_LENGTH = 4
self.portHandler = port_handler.PortHandler(self.DEVICENAME)
self.packetHandler = packet_handler.PacketHandler(self.PROTOCOL_VERSION)
# Initialize GroupSyncWrite
self.groupSyncWriteCurrent = group_sync_write.GroupSyncWrite(self.portHandler, self.packetHandler, self.ADDR_PRO_GOAL_CURRENT,
self.ADDR_PRO_GOAL_CURRENT_LENGTH)
self.groupSyncWritePosition = group_sync_write.GroupSyncWrite(self.portHandler, self.packetHandler, self.ADDR_PRO_GOAL_POSITION,
self.ADDR_PRO_GOAL_POSITION_LENGTH)
self.groupSyncWriteVelocity = group_sync_write.GroupSyncWrite(self.portHandler, self.packetHandler, self.ADDR_PRO_GOAL_VELOCITY,
self.ADDR_PRO_GOAL_VELOCITY_LENGTH)
# Initialize GroupSyncRead
self.groupSyncReadPosition = group_sync_read.GroupSyncRead(self.portHandler, self.packetHandler, self.ADDR_PRO_PRESENT_POSITION,
self.ADDR_PRO_PRESENT_POSITION_LENGTH)
self.groupSyncReadVelocity = group_sync_read.GroupSyncRead(self.portHandler, self.packetHandler, self.ADDR_PRO_PRESENT_VELOCITY,
self.ADDR_PRO_PRESENT_VELOCITY_LENGTH)
# Open Port
if self.portHandler.openPort():
print("Succeeded to open the port")
else:
print("Failed to open the port")
if self.portHandler.setBaudRate(self.BAUDRATE):
print("Succeeded to change the baudrate")
else:
print("Failed to change the baudrate")
# GroupSyncRead addparam
for i in dxl_id:
dxl_addparam_result = self.groupSyncReadPosition.addParam(i)
if dxl_addparam_result != True:
print("[ID:%03d] groupSyncReadPosition addparam failed" % i)
dxl_addparam_result = self.groupSyncReadVelocity.addParam(i)
if dxl_addparam_result != True:
print("[ID:%03d] groupSyncReadVelocity addparam failed" % i)
print('Initialize Completed!')
def __init__(self, usb):
Device.__init__(self)
self.usb = usb
self.timer_stats = hello_utils.TimerStats()
self.pt_lock = threading.RLock()
self.port_handler = prh.PortHandler(usb)
self.port_handler.openPort()
self.port_handler.setBaudRate(57600)
self.packet_handler = pch.PacketHandler(2.0)
self.status = {}
self.motors = {}
self.readers = {}
def __init__(self, controller_namespace, controllers):
print("HELLO FROM JOINT_TRAJECTORY_CONTROLLER")
rospy.loginfo("HELLO_FROM_JOINT_TRAJECTORY_CONTROLLER")
for controller in controllers:
print(controller)
self.update_rate = 1000
self.state_update_rate = 50
self.trajectory = []
self.port_namespace = "l_arm_port" #TODO Irvin added
self.controller_namespace = controller_namespace
self.joint_names = [c.joint_name for c in controllers] # IRVIN UPDATED
self.joint_to_controller = {}
for c in controllers:
self.joint_to_controller[c.joint_name] = c
self.port_to_joints = {}
for c in controllers:
if c.port_namespace not in self.port_to_joints: self.port_to_joints[c.port_namespace] = []
self.port_to_joints[c.port_namespace].append(c.joint_name)
# self.port_to_io = {}
# for c in controllers:
# if c.port_namespace in self.port_to_io: continue
# self.port_to_io[c.port_namespace] = c.dxl_io
# NOTE: Note that if we are doing mutliple port management
# we also need to reference the different port_handler(s) and packet_handler(s)
# for each respective servo
self.port_handler = {}
self.packet_handler = {}
for c in controllers:
rospy.logwarn("C.PORTNAMESPACE" + c.port_namespace)
if c.port_namespace in self.port_handler: continue
self.port_handler[c.port_namespace] = c.port_handler
self.packet_handler[c.port_namespace] = c.packet_handler
rospy.logwarn(type(c.port_namespace))
# NOTE: Note that if we are doing mutliple port management
# we also need to reference the different port_handler(s) and packet_handler(s)
# for each respective servo
# self.packet_handler = {}
# for c in controllers:
# if c.port_namespace in self.port_namespace: continue
# self.packet_handler[c.port_namespace] = c.packet_handler
self.joint_states = dict(zip(self.joint_names, [c.joint_state for c in controllers]))
self.num_joints = len(self.joint_names)
self.joint_to_idx = dict(zip(self.joint_names, range(self.num_joints)))
self.port_handler_irvin = port_h.PortHandler("/dev/ttyUSB0")
self.packet_handler_irvin = packet_h.PacketHandler(2.0)
def connect(self):
"""
Connects up physical port with the port handler, and initialize packet handler
"""
try:
# Port and packet handler set up
self.port_handler = port_h.PortHandler(self.port_name)
self.packet_handler = packet_h.PacketHandler(self.protocol_version)
# Set up port and baud rate
self.port_handler.openPort()
self.port_handler.setBaudRate(self.baud_rate)
self.__find_motors()
except rospy.ROSInterruptException: pass
self.running = True
def __init__(self, dxl_id, usb, port_handler=None, pt_lock=None):
Device.__init__(self)
self.dxl_id = dxl_id
self.comm_errors = 0
#Make access to portHandler threadsafe
if pt_lock is None:
self.pt_lock = threading.RLock()
else:
self.pt_lock = pt_lock
self.usb = usb
#Allow sharing of port handler across multiple servos
if port_handler is None:
self.port_handler = prh.PortHandler(usb)
self.port_handler.openPort()
self.port_handler.setBaudRate(57600)
else:
self.port_handler = port_handler
self.packet_handler = pch.PacketHandler(2.0)
def __init__(self, usb, verbose=False):
Device.__init__(self, verbose)
self.usb = usb
self.timer_stats = hello_utils.TimerStats()
self.pt_lock = threading.RLock()
try:
self.port_handler = prh.PortHandler(usb)
self.port_handler.openPort()
self.port_handler.setBaudRate(57600)
self.packet_handler = pch.PacketHandler(2.0)
self.hw_valid = True
except serial.SerialException as e:
self.packet_handler = None
self.port_handler = None
self.hw_valid = False
print("SerialException({0}): {1}".format(e.errno, e.strerror))
self.status = {}
self.motors = {}
self.readers = {}
self.runstop_last = None
def __init__(self, usb, name):
Device.__init__(self, name)
self.usb = usb
self.pt_lock = threading.RLock()
try:
prh.LATENCY_TIMER = self.params['dxl_latency_timer']
self.port_handler = prh.PortHandler(usb)
self.port_handler.openPort()
self.port_handler.setBaudRate(int(self.params['baud']))
self.packet_handler = pch.PacketHandler(2.0)
self.hw_valid = True
except serial.SerialException as e:
self.packet_handler = None
self.port_handler = None
self.hw_valid = False
self.logger.error("SerialException({0}): {1}".format(
e.errno, e.strerror))
self.status = {}
self.motors = {}
self.readers = {}
self.comm_errors = DynamixelCommErrorStats(name, logger=self.logger)
#! /usr/bin/env python
from dynamixel_sdk import port_handler
p1 = port_handler.PortHandler('/dev/ttyUSB0')
baud = p1.setBaudRate(4000000)
print(p1.baudrate)
