pymycobot 3.5.0.dev2__tar.gz → 3.5.0.dev4__tar.gz

{pymycobot-3.5.0.dev2/pymycobot.egg-info → pymycobot-3.5.0.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pymycobot
-Version: 3.5.0.dev2
+Version: 3.5.0.dev4
 Summary: Python API for serial communication of MyCobot.
 Home-page: https://github.com/elephantrobotics/pymycobot
 Author: Elephantrobotics

{pymycobot-3.5.0.dev2 → pymycobot-3.5.0.dev4}/pymycobot/__init__.py

@@ -61,7 +61,7 @@ if sys.platform == "linux":
     from pymycobot.mybuddyemoticon import MyBuddyEmoticon
     __all__.append("MyBuddyEmoticon")
 
-__version__ = "3.5.0dev2" 
+__version__ = "3.5.0dev4" 
 __author__ = "Elephantrobotics"
 __email__ = "weiquan.xu@elephantrobotics.com"
 __git_url__ = "https://github.com/elephantrobotics/pymycobot"

{pymycobot-3.5.0.dev2 → pymycobot-3.5.0.dev4}/pymycobot/error.py

@@ -16,24 +16,31 @@ MAX_ANGLE = 190.0
 class MyCobotDataException(Exception):
     pass
 
+
 class MercuryDataException(Exception):
     pass
 
+
 class MyAgvDataException(Exception):
     pass
 
+
 class MechArmDataException(Exception):
     pass
 
+
 class MyArmDataException(Exception):
     pass
 
+
 class UltraArmDataException(Exception):
     pass
 
+
 class MyPalletizerDataException(Exception):
     pass
 
+
 class MyBuddyDataException(Exception):
     pass
 
@@ -41,19 +48,24 @@ class MyBuddyDataException(Exception):
 def check_boolean(b):
     if b != 0 and b != 1:
         raise MyCobotDataException("This parameter needs to be 0 or 1")
-    
+
+
 def check_rgb_value(value, exception_class, class_name):
     rgb_str = ["r", "g", "b"]
     for i, v in enumerate(value):
         if not (0 <= v <= 255):
             raise exception_class(
-                "The RGB value for {} needs to be 0 ~ 255, but received the {} is {}".format(class_name, rgb_str[i], v)
+                "The RGB value for {} needs to be 0 ~ 255, but received the {} is {}".format(
+                    class_name, rgb_str[i], v)
             )
 
+
 def check_value_type(parameter, value_type, exception_class, _type):
     if value_type is not _type:
-        raise exception_class("The acceptable parameter {} should be an {}, but the received {}".format(parameter, _type, value_type))
-    
+        raise exception_class("The acceptable parameter {} should be an {}, but the received {}".format(
+            parameter, _type, value_type))
+
+
 def check_coords(value, robot_limit, class_name, exception_class):
     if len(value) != 6:
         raise exception_class("The length of `coords` must be 6.")
@@ -64,7 +76,8 @@ def check_coords(value, robot_limit, class_name, exception_class):
                     idx, robot_limit[class_name]["coords_min"][idx], robot_limit[class_name]["coords_max"][idx], coord
                 )
             )
-            
+
+
 def check_0_or_1(parameter, value, range_data, value_type, exception_class, _type):
     check_value_type(parameter, value_type, exception_class, _type)
     if value not in range_data:
@@ -76,63 +89,75 @@ def check_0_or_1(parameter, value, range_data, value_type, exception_class, _typ
                 error += " or "
         error += ", but the received value is {}".format(value)
         raise exception_class(error)
-    
+
+
 def check_id(value, id_list, exception_class):
     raise exception_class(
         "The id not right, should be in {0}, but received {1}.".format(
-        id_list, value
+            id_list, value
         )
     )
-    
+
+
 def public_check(parameter_list, kwargs, robot_limit, class_name, exception_class):
     for parameter in parameter_list[1:]:
         value = kwargs.get(parameter, None)
         value_type = type(value)
         if parameter == 'id' and value not in robot_limit[class_name][parameter]:
-            check_id(value, robot_limit[class_name][parameter], exception_class)
+            check_id(value, robot_limit[class_name]
+                     [parameter], exception_class)
         elif parameter == 'rgb':
             check_rgb_value(value, exception_class, class_name)
         elif parameter == 'value':
             check_value_type(parameter, value_type, exception_class, int)
             if value < 0 or value > 4096:
-                raise exception_class("The range of {} is 0 ~ 4096, but the received value is {}".format(parameter, value))
+                raise exception_class(
+                    "The range of {} is 0 ~ 4096, but the received value is {}".format(parameter, value))
         elif parameter == 'pin_mode':
             check_value_type(parameter, value_type, exception_class, int)
-            if value not in [0,1,2]:
-                raise exception_class("The data supported by parameter {} is 0 or 1 or 2, but the received value is {}".format(parameter, value))
+            if value not in [0, 1, 2]:
+                raise exception_class(
+                    "The data supported by parameter {} is 0 or 1 or 2, but the received value is {}".format(parameter, value))
         elif parameter == 'pin_signal':
-            check_0_or_1(parameter, value, [0, 1], value_type, exception_class, int)
+            check_0_or_1(parameter, value, [0, 1],
+                         value_type, exception_class, int)
         elif parameter == 'speed':
             check_value_type(parameter, value_type, exception_class, int)
-            if not 1 <= value <= 100: 
+            if not 1 <= value <= 100:
                 raise exception_class(
                     "speed value not right, should be 1 ~ 100, the received speed is %s"
                     % value
                 )
         elif parameter == 'flag':
-            check_0_or_1(parameter, value, [0, 1, 254], value_type, exception_class, int)
+            check_0_or_1(parameter, value, [
+                         0, 1, 254], value_type, exception_class, int)
         elif parameter == 'gripper_type':
-            check_0_or_1(parameter, value, [1, 3, 4], value_type, exception_class, int)
+            check_0_or_1(parameter, value, [
+                         1, 3, 4], value_type, exception_class, int)
         elif parameter == '_type_1':
-            check_0_or_1(parameter, value, [1, 2, 3, 4], value_type, exception_class, int)
+            check_0_or_1(parameter, value, [
+                         1, 2, 3, 4], value_type, exception_class, int)
             # if value not in [0, 1, 10]:
             #     raise exception_class("The data supported by parameter {} is 0 or 1 or 10, but the received value is {}".format(parameter, value))
         elif parameter == 'gripper_value':
             check_value_type(parameter, value_type, exception_class, int)
             if value < 0 or value > 100:
-                raise exception_class("The range of {} is 0 ~ 100, but the received value is {}".format(parameter, value))
+                raise exception_class(
+                    "The range of {} is 0 ~ 100, but the received value is {}".format(parameter, value))
         elif parameter in ['account', 'password']:
             check_value_type(parameter, value_type, exception_class, str)
         # TODO 280/320共用MyCobot，无法进行数据限位
         # elif parameter == 'coords':
         #     check_coords(value, robot_limit, class_name, exception_class)
         elif parameter in ['rftype', 'move_type', 'end', 'is_linear', 'status', 'mode', 'direction']:
-            check_0_or_1(parameter, value, [0, 1], value_type, exception_class, int)
+            check_0_or_1(parameter, value, [0, 1],
+                         value_type, exception_class, int)
         elif parameter == 'acceleration':
             check_value_type(parameter, value_type, exception_class, int)
             if not 1 <= value <= 100:
                 raise exception_class(
-                    "{} value not right, should be 1 ~ 100, the received is {}".format(parameter, value)
+                    "{} value not right, should be 1 ~ 100, the received is {}".format(
+                        parameter, value)
                 )
         elif parameter == 'angle':
             id = kwargs.get('id', None)
@@ -144,24 +169,29 @@ def public_check(parameter_list, kwargs, robot_limit, class_name, exception_clas
                     )
                 )
         elif parameter == 'encoders':
-            if  "MyCobot" in class_name or "MechArm" in class_name:
+            if "MyCobot" in class_name or "MechArm" in class_name:
                 if len(value) != 6:
-                    raise exception_class("The length of `encoders` must be 6.")
+                    raise exception_class(
+                        "The length of `encoders` must be 6.")
             elif "MyPalletizer" in class_name:
                 if len(value) != 4:
-                    raise exception_class("The length of `encoders` must be 4.")
+                    raise exception_class(
+                        "The length of `encoders` must be 4.")
             elif "MyPalletizer" in class_name:
                 if len(value) != 7:
-                    raise exception_class("The length of `encoders` must be 7.")
+                    raise exception_class(
+                        "The length of `encoders` must be 7.")
             for data in value:
                 data_type = type(data)
                 check_value_type(parameter, data_type, exception_class, int)
                 if data < 0 or data > 4096:
-                    raise exception_class("The range of encoder is 0 ~ 4096, but the received value is {}".format(data))
+                    raise exception_class(
+                        "The range of encoder is 0 ~ 4096, but the received value is {}".format(data))
         elif parameter == 'speeds':
-            if  "MyCobot" in class_name or "MechArm" in class_name:
+            if "MyCobot" in class_name or "MechArm" in class_name:
                 if len(value) not in [6, 7]:
-                    raise exception_class("The length of `speeds` must be 6. but the received value is {}".format(value))
+                    raise exception_class(
+                        "The length of `speeds` must be 6. but the received value is {}".format(value))
             elif "MyPalletizer" in class_name:
                 if len(value) != 4:
                     raise exception_class("The length of `speeds` must be 4.")
@@ -172,7 +202,8 @@ def public_check(parameter_list, kwargs, robot_limit, class_name, exception_clas
                 data_type = type(data)
                 check_value_type(parameter, data_type, exception_class, int)
                 if data < 0 or data > 3400:
-                    raise exception_class("The range of speed is 0 ~ 3400, but the received value is {}".format(data))
+                    raise exception_class(
+                        "The range of speed is 0 ~ 3400, but the received value is {}".format(data))
         elif parameter in ['servo_id_pdi', 'encode_id']:
             check_value_type(parameter, value_type, exception_class, int)
             # if  "MyCobot" in class_name or "MechArm" in class_name:
@@ -180,135 +211,142 @@ def public_check(parameter_list, kwargs, robot_limit, class_name, exception_clas
             #             raise exception_class("The range of id is 1 ~ 6, but the received is {}".format(value))
             if "MyPalletizer" in class_name:
                 if value < 1 or value > 4:
-                        raise exception_class("The range of id is 1 ~ 4, but the received is {}".format(value))
+                    raise exception_class(
+                        "The range of id is 1 ~ 4, but the received is {}".format(value))
             elif "MyArm" in class_name or "MyCobot" in class_name or "MechArm" in class_name:
                 if value < 1 or value > 7:
-                        raise exception_class("The range of id is 1 ~ 7, but the received is {}".format(value))
+                    raise exception_class(
+                        "The range of id is 1 ~ 7, but the received is {}".format(value))
         elif parameter == "torque":
             torque_min = 150
             torque_max = 980
             if value < torque_min or value > torque_max:
-                raise exception_class("The range of torque is {} ~ {}, but the received is {}".format(torque_min, torque_max, value))
+                raise exception_class("The range of torque is {} ~ {}, but the received is {}".format(
+                    torque_min, torque_max, value))
         elif parameter == "current":
             current_min = 1
             current_max = 500
             if value < current_min or value > current_max:
-                raise exception_class("The range of current is {} ~ {}, but the received is {}".format(current_min, current_max, value))
+                raise exception_class("The range of current is {} ~ {}, but the received is {}".format(
+                    current_min, current_max, value))
         elif parameter == 'end_direction':
-            check_0_or_1(parameter, value, [1, 2, 3], value_type, exception_class, int)
+            check_0_or_1(parameter, value, [
+                         1, 2, 3], value_type, exception_class, int)
+
 
 def calibration_parameters(**kwargs):
     robot_limit = {
-    "Mercury":{
-        "id":[1,2,3,4,5,6,11,12,13],
-        "angles_min":[-178, -74, -180, -178, -20, -180, -60, -140, -120],
-        "angles_max":[178, 130, 178, 10, 178, 273, 180, 0, 190, 120],
-        "coords_min":[-441.37, -441.37, -206.52, -180, -180, -180],
-        "coords_max":[441.37, 441.37, 628.02, 180, 180, 180]
-    },
-    "MercurySocket":{
-        "id":[1,2,3,4,5,6,11,12,13],
-        "angles_min":[-178, -74, -180, -178, -20, -180, -60, -140, -120],
-        "angles_max":[178, 130, 178, 10, 178, 273, 180, 0, 190, 120],
-        "coords_min":[-466, -466, -240, -180, -180, -180],
-        "coords_max":[466, 466, 531, 180, 180, 180]
-    },
-    "MyCobot":{
-        "id":[1,2,3,4,5,6, 7],
-        "angles_min":[-168, -135, -150, -145, -165, -180],
-        "angles_max":[168, 135, 150, 145, 165, 180],
-        "coords_min":[-350, -350, -70, -180, -180, -180],
-        "coords_max":[350, 350, 523.9, 180, 180, 180]
-    },
-    "MyCobotSocket":{
-        "id":[1,2,3,4,5,6, 7],
-        "angles_min":[-168, -135, -150, -145, -165, -180],
-        "angles_max":[168, 135, 150, 145, 165, 180],
-        "coords_min":[-350, -350, -70, -180, -180, -180],
-        "coords_max":[350, 350, 523.9, 180, 180, 180]
-    },
-    "MechArm":{
-        "id":[1,2,3,4,5,6, 7],
-        "angles_min":[-165, -90, -180, -165, -115, -175],
-        "angles_max":[165, 90, 70, 165, 115, 175],
-        "coords_min":[-272, -272, -36, -180, -180, -180],
-        "coords_max":[272, 272, 408.9, 180, 180, 180]
-    },
-    "MechArmSocket":{
-        "id":[1,2,3,4,5,6, 7],
-        "angles_min":[-165, -90, -180, -165, -115, -175],
-        "angles_max":[165, 90, 70, 165, 115, 175],
-        "coords_min":[-272, -272, -36, -180, -180, -180],
-        "coords_max":[272, 272, 408.9, 180, 180, 180]
-    },
-    "MyArm":{
-        "id":[1,2,3,4,5,6,7,8],
-        "angles_min":[-160, -70, -170, -113, -170, -115, -180],
-        "angles_max":[160, 115, 170, 75, 170, 115, 180],
-        "coords_min":[-310, -310, -140, -180, -180, -180],
-        "coords_max":[310, 310, 480, 180, 180, 180]
-    },
-    "MyArmSocket":{
-        "id":[1,2,3,4,5,6,7,8],
-        "angles_min":[-160, -70, -170, -113, -170, -115, -180],
-        "angles_max":[160, 115, 170, 75, 170, 115, 180],
-        "coords_min":[-310, -310, -140, -180, -180, -180],
-        "coords_max":[310, 310, 480, 180, 180, 180]
-    },
-    "MyPalletizer":{
-        "id":[1,2,3,4, 7],
-        "angles_min":[-162, -2, -92, -180],
-        "angles_max":[162, 90, 60, 180],
-        "coords_min":[-260, -260, -15, -180],
-        "coords_max":[260, 260, 357.58, 180]
-    },
-    "MyPalletizerSocket":{
-        "id":[1,2,3,4, 7],
-        "angles_min":[-162, -2, -92, -180],
-        "angles_max":[162, 90, 60, 180],
-        "coords_min":[-260, -260, -15, -180],
-        "coords_max":[260, 260, 357.58, 180]
-    },
-    "UltraArm":{
-        "id":[1,2,3,4, 7],
-        "angles_min":[-150, -20, -5, -180],
-        "angles_max":[170, 90, 110, 180],
-        "coords_min":[-340, -340, 0, -180],
-        "coords_max":[340, 340, 270.58, 180]
-    },
-    "MyBuddy":{
-        "id":[1,2,3,4,5,6, 7],
-        "angles_min":[-165, -165, -165, -165, -165, -175],
-        "angles_max":[165, 165, 165, 165, 165, 175],
-        "waist_angle_min":-120,
-        "waist_angle_max":120,
-        "left_coords_min":[0, -40, 0, -180,-180,-180],
-        "left_coords_max":[250, 260, 480, 180,180,180],
-        "right_coords_min":[0, -260, 0, -180,-180,-180],
-        "right_coords_max":[250, 40, 480, 180,180,180]
-    },
-    "MyBuddySocket":{
-        "id":[1,2,3,4,5,6, 7],
-        "angles_min":[-165, -165, -165, -165, -165, -175],
-        "angles_max":[165, 165, 165, 165, 165, 175],
-        "waist_angle_min":-120,
-        "waist_angle_max":120,
-        "left_coords_min":[0, -40, 0, -180,-180,-180],
-        "left_coords_max":[250, 260, 480, 180,180,180],
-        "right_coords_min":[0, -260, 0, -180,-180,-180],
-        "right_coords_max":[250, 40, 480, 180,180,180]
+        "Mercury": {
+            "id": [1, 2, 3, 4, 5, 6, 11, 12, 13],
+            "angles_min": [-165, -55, -180, -165, -20, -180, -60, -140, -120],
+            "angles_max": [165, 95, 5, 165, 273, 180, 0, 190, 120],
+            "coords_min": [-441.37, -441.37, -206.52, -180, -180, -180],
+            "coords_max": [441.37, 441.37, 628.02, 180, 180, 180]
+        },
+        "MercurySocket": {
+            "id": [1, 2, 3, 4, 5, 6, 11, 12, 13],
+            "angles_min": [-165, -55, -180, -165, -20, -180, -60, -140, -120],
+            "angles_max": [165, 95, 5, 165, 273, 180, 0, 190, 120],
+            "coords_min": [-441.37, -441.37, -206.52, -180, -180, -180],
+            "coords_max": [441.37, 441.37, 628.02, 180, 180, 180]
+        },
+        "MyCobot": {
+            "id": [1, 2, 3, 4, 5, 6, 7],
+            "angles_min": [-168, -135, -150, -145, -165, -180],
+            "angles_max": [168, 135, 150, 145, 165, 180],
+            "coords_min": [-350, -350, -70, -180, -180, -180],
+            "coords_max": [350, 350, 523.9, 180, 180, 180]
+        },
+        "MyCobotSocket": {
+            "id": [1, 2, 3, 4, 5, 6, 7],
+            "angles_min": [-168, -135, -150, -145, -165, -180],
+            "angles_max": [168, 135, 150, 145, 165, 180],
+            "coords_min": [-350, -350, -70, -180, -180, -180],
+            "coords_max": [350, 350, 523.9, 180, 180, 180]
+        },
+        "MechArm": {
+            "id": [1, 2, 3, 4, 5, 6, 7],
+            "angles_min": [-165, -90, -180, -165, -115, -175],
+            "angles_max": [165, 90, 70, 165, 115, 175],
+            "coords_min": [-272, -272, -36, -180, -180, -180],
+            "coords_max": [272, 272, 408.9, 180, 180, 180]
+        },
+        "MechArmSocket": {
+            "id": [1, 2, 3, 4, 5, 6, 7],
+            "angles_min": [-165, -90, -180, -165, -115, -175],
+            "angles_max": [165, 90, 70, 165, 115, 175],
+            "coords_min": [-272, -272, -36, -180, -180, -180],
+            "coords_max": [272, 272, 408.9, 180, 180, 180]
+        },
+        "MyArm": {
+            "id": [1, 2, 3, 4, 5, 6, 7, 8],
+            "angles_min": [-160, -70, -170, -113, -170, -115, -180],
+            "angles_max": [160, 115, 170, 75, 170, 115, 180],
+            "coords_min": [-310, -310, -140, -180, -180, -180],
+            "coords_max": [310, 310, 480, 180, 180, 180]
+        },
+        "MyArmSocket": {
+            "id": [1, 2, 3, 4, 5, 6, 7, 8],
+            "angles_min": [-160, -70, -170, -113, -170, -115, -180],
+            "angles_max": [160, 115, 170, 75, 170, 115, 180],
+            "coords_min": [-310, -310, -140, -180, -180, -180],
+            "coords_max": [310, 310, 480, 180, 180, 180]
+        },
+        "MyPalletizer": {
+            "id": [1, 2, 3, 4, 7],
+            "angles_min": [-162, -2, -92, -180],
+            "angles_max": [162, 90, 60, 180],
+            "coords_min": [-260, -260, -15, -180],
+            "coords_max": [260, 260, 357.58, 180]
+        },
+        "MyPalletizerSocket": {
+            "id": [1, 2, 3, 4, 7],
+            "angles_min": [-162, -2, -92, -180],
+            "angles_max": [162, 90, 60, 180],
+            "coords_min": [-260, -260, -15, -180],
+            "coords_max": [260, 260, 357.58, 180]
+        },
+        "UltraArm": {
+            "id": [1, 2, 3, 4, 7],
+            "angles_min": [-150, -20, -5, -180],
+            "angles_max": [170, 90, 110, 180],
+            "coords_min": [-340, -340, 0, -180],
+            "coords_max": [340, 340, 270.58, 180]
+        },
+        "MyBuddy": {
+            "id": [1, 2, 3, 4, 5, 6, 7],
+            "angles_min": [-165, -165, -165, -165, -165, -175],
+            "angles_max": [165, 165, 165, 165, 165, 175],
+            "waist_angle_min": -120,
+            "waist_angle_max": 120,
+            "left_coords_min": [0, -40, 0, -180, -180, -180],
+            "left_coords_max": [250, 260, 480, 180, 180, 180],
+            "right_coords_min": [0, -260, 0, -180, -180, -180],
+            "right_coords_max": [250, 40, 480, 180, 180, 180]
+        },
+        "MyBuddySocket": {
+            "id": [1, 2, 3, 4, 5, 6, 7],
+            "angles_min": [-165, -165, -165, -165, -165, -175],
+            "angles_max": [165, 165, 165, 165, 165, 175],
+            "waist_angle_min": -120,
+            "waist_angle_max": 120,
+            "left_coords_min": [0, -40, 0, -180, -180, -180],
+            "left_coords_max": [250, 260, 480, 180, 180, 180],
+            "right_coords_min": [0, -260, 0, -180, -180, -180],
+            "right_coords_max": [250, 40, 480, 180, 180, 180]
+        }
     }
-}
     parameter_list = list(kwargs.keys())
-    class_name =  kwargs.get("class_name", None)
+    class_name = kwargs.get("class_name", None)
     if class_name in ["Mercury", "MercurySocket"]:
         for parameter in parameter_list[1:]:
             value = kwargs.get(parameter, None)
             if parameter == 'id' and value not in robot_limit[class_name][parameter]:
-                check_id(value, robot_limit[class_name][parameter], MercuryDataException)
+                check_id(value, robot_limit[class_name]
+                         [parameter], MercuryDataException)
             elif parameter == 'angle':
                 id = kwargs.get('id', None)
-                if id in [11,12,13]:
+                if id in [11, 12, 13]:
                     index = robot_limit[class_name]['id'][id-4] - 4
                 else:
                     index = robot_limit[class_name]['id'][id-1] - 1
@@ -330,7 +368,7 @@ def calibration_parameters(**kwargs):
             #             )
 
             elif parameter == 'coord':
-                
+
                 index = kwargs.get('id', None) - 1
                 if value < robot_limit[class_name]["coords_min"][index] or value > robot_limit[class_name]["coords_max"][index]:
                     raise MercuryDataException(
@@ -339,7 +377,8 @@ def calibration_parameters(**kwargs):
                         )
                     )
             elif parameter == 'coords':
-                check_coords(value, robot_limit, class_name, MercuryDataException)
+                check_coords(value, robot_limit, class_name,
+                             MercuryDataException)
 
             elif parameter == 'speed' and not 1 <= value <= 100:
                 raise MercuryDataException(
@@ -352,30 +391,38 @@ def calibration_parameters(**kwargs):
             # if direction is not None:
             elif parameter in ['direction', 'flag', 'value']:
                 if value not in [0, 1]:
-                    raise MercuryDataException("{} only supports 0 or 1, but received {}".format(parameter, value))
-                
+                    raise MercuryDataException(
+                        "{} only supports 0 or 1, but received {}".format(parameter, value))
+
             elif parameter == 'coord_id':
                 if value < 1 or value > 6:
-                    raise MercuryDataException("coord_id only supports 1 ~ 6, but received {}".format(value))
-                
+                    raise MercuryDataException(
+                        "coord_id only supports 1 ~ 6, but received {}".format(value))
+
             elif parameter == 'solution_angle':
                 if value > 90 or value < -90:
-                    raise MercuryDataException("The angle range is -90° ~ 90°, but received {}".format(value))
+                    raise MercuryDataException(
+                        "The angle range is -90° ~ 90°, but received {}".format(value))
             elif parameter == 'address':
                 if value < 32 or value > 34:
-                    raise MercuryDataException("The angle address is 32 ~ 34, but received {}".format(value))
+                    raise MercuryDataException(
+                        "The angle address is 32 ~ 34, but received {}".format(value))
             elif parameter == 'value':
                 if value < 1 or value > 32000:
-                    raise MercuryDataException("The angle value is 1 ~ 32000, but received {}".format(value))
+                    raise MercuryDataException(
+                        "The angle value is 1 ~ 32000, but received {}".format(value))
             elif parameter == "servo_restore":
-                if value not in [1,2,3,4,5,6,7,13,254]:
-                    raise MercuryDataException("The joint_id should be in [1,2,3,4,5,6,7,13,254], but received {}".format(value))
+                if value not in [1, 2, 3, 4, 5, 6, 7, 13, 254]:
+                    raise MercuryDataException(
+                        "The joint_id should be in [1,2,3,4,5,6,7,13,254], but received {}".format(value))
             elif parameter == "data_len":
                 if value < 1 or value > 45:
-                    raise MercuryDataException("The parameter data_len data range only supports 1 ~ 45, but received {}".format(value))
+                    raise MercuryDataException(
+                        "The parameter data_len data range only supports 1 ~ 45, but received {}".format(value))
             elif parameter == "max_time":
                 if value < 0:
-                    raise MercuryDataException("The parameter max_time must be greater than or equal to 0, but received {}".format(value))
+                    raise MercuryDataException(
+                        "The parameter max_time must be greater than or equal to 0, but received {}".format(value))
     elif class_name == "MyAgv":
         for parameter in parameter_list[1:]:
             value = kwargs.get(parameter, None)
@@ -383,23 +430,31 @@ def calibration_parameters(**kwargs):
                 check_rgb_value(value, MyAgvDataException, class_name)
             elif parameter == 'led_mode':
                 if value not in [1, 2]:
-                    raise MyAgvDataException("led mode only supports 1 or 2, but received is {}".format(value))
+                    raise MyAgvDataException(
+                        "led mode only supports 1 or 2, but received is {}".format(value))
             elif parameter == 'direction_1':
                 if value < 0 or value > 255:
-                    raise MyAgvDataException("The range of direction_1 is 0 ~ 255, but the received value is {}".format(value))
+                    raise MyAgvDataException(
+                        "The range of direction_1 is 0 ~ 255, but the received value is {}".format(value))
             elif parameter == 'direction_2':
                 if value < 0 or value > 255:
-                    raise MyAgvDataException("The range of direction_2 is 0 ~ 255, but the received value is {}".format(value))
+                    raise MyAgvDataException(
+                        "The range of direction_2 is 0 ~ 255, but the received value is {}".format(value))
             elif parameter == 'direction_3':
                 if value < 0 or value > 255:
-                    raise MyAgvDataException("The range of direction_3 is 0 ~ 255, but the received value is {}".format(value))
+                    raise MyAgvDataException(
+                        "The range of direction_3 is 0 ~ 255, but the received value is {}".format(value))
             elif parameter == 'data':
                 if value < 1 or value > 127:
-                    raise MyAgvDataException("The range of {} is 1 ~ 127, but the received value is {}".format(parameter, value))
-    
+                    raise MyAgvDataException(
+                        "The range of {} is 1 ~ 127, but the received value is {}".format(parameter, value))
+
     elif class_name in ["MyCobot", "MyCobotSocket"]:
-        public_check(parameter_list, kwargs, robot_limit, class_name, MyCobotDataException)
+        public_check(parameter_list, kwargs, robot_limit,
+                     class_name, MyCobotDataException)
     elif class_name in ["MechArm", "MechArmSocket"]:
-        public_check(parameter_list, kwargs, robot_limit, class_name, MechArmDataException)
+        public_check(parameter_list, kwargs, robot_limit,
+                     class_name, MechArmDataException)
     elif class_name in ["MyArm", "MyArmSocket"]:
-        public_check(parameter_list, kwargs, robot_limit, class_name, MyArmDataException)
+        public_check(parameter_list, kwargs, robot_limit,
+                     class_name, MyArmDataException)

{pymycobot-3.5.0.dev2 → pymycobot-3.5.0.dev4}/pymycobot/mercury_api.py

@@ -121,7 +121,7 @@ class MercuryCommandGenerator(CommandGenerator):
                         byte_value = int.from_bytes(valid_data[i:i+4], byteorder='big', signed=True)
                         i+=4
                         res.append(byte_value)
-                elif data_len == 6 and genre in [ProtocolCode.GET_SERVO_STATUS, ProtocolCode.GET_SERVO_VOLTAGES, ProtocolCode.GET_SERVO_CURRENTS]:
+                elif data_len == 6 and genre in [ProtocolCode.GET_SERVO_STATUS, ProtocolCode.GET_SERVO_VOLTAGES, ProtocolCode.GET_SERVO_CURRENTS, ProtocolCode.GET_MODEL_DIRECTION]:
                     for i in range(data_len):
                         res.append(valid_data[i])
                 elif data_len == 24:
@@ -870,7 +870,7 @@ class MercuryCommandGenerator(CommandGenerator):
         """
         return self._mesg(ProtocolCode.MERCURY_GET_POS_OVER_SHOOT, has_reply=True)
     
-    def stop(self, deceleration=False):
+    def stop(self, deceleration=0):
         """Robot stops moving
 
         Args:
@@ -879,12 +879,12 @@ class MercuryCommandGenerator(CommandGenerator):
         Returns:
             int: 1 - Stop completion
         """
-        if deceleration:
-            return self._mesg(ProtocolCode.STOP, has_reply=True)
-        else:
+        if deceleration == 1:
             return self._mesg(ProtocolCode.STOP, 1, has_reply=True)
+        else:
+            return self._mesg(ProtocolCode.STOP, has_reply=True)    
         
-    def pause(self, deceleration=False):
+    def pause(self, deceleration=0):
         """Robot pauses movement
 
         Args:
@@ -893,10 +893,11 @@ class MercuryCommandGenerator(CommandGenerator):
         Returns:
             int: 1 - pause completion
         """
-        if deceleration:
-            return self._mesg(ProtocolCode.PAUSE, has_reply=True)
-        else:
+        if deceleration == 1:
             return self._mesg(ProtocolCode.PAUSE, 1, has_reply=True)
+        else:
+            return self._mesg(ProtocolCode.PAUSE, has_reply=True)
+        
         
     def get_modified_version(self):
         return self._mesg(ProtocolCode.ROBOT_VERSION, has_reply=True)

{pymycobot-3.5.0.dev2 → pymycobot-3.5.0.dev4/pymycobot.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pymycobot
-Version: 3.5.0.dev2
+Version: 3.5.0.dev4
 Summary: Python API for serial communication of MyCobot.
 Home-page: https://github.com/elephantrobotics/pymycobot
 Author: Elephantrobotics