diff --git a/example/go2/high_level/go2_sport_client.py b/example/go2/high_level/go2_sport_client.py
index b14d79d0..23873e65 100644
--- a/example/go2/high_level/go2_sport_client.py
+++ b/example/go2/high_level/go2_sport_client.py
@@ -24,17 +24,14 @@ class TestOption:
     TestOption(name="move lateral", id=4),    
     TestOption(name="move rotate", id=5),  
     TestOption(name="stop_move", id=6),  
-    TestOption(name="switch_gait", id=7),    
-    TestOption(name="switch_gait", id=8),
+    TestOption(name="hand stand", id=7),
     TestOption(name="balanced stand", id=9),     
-    TestOption(name="recovery", id=10),
     TestOption(name="recovery", id=10),       
     TestOption(name="left flip", id=11),      
     TestOption(name="back flip", id=12),
     TestOption(name="free walk", id=13),  
     TestOption(name="free bound", id=14), 
     TestOption(name="free avoid", id=15),  
-    TestOption(name="walk stair", id=16), 
     TestOption(name="walk upright", id=17),
     TestOption(name="cross step", id=18),
     TestOption(name="free jump", id=19)       
@@ -71,14 +68,13 @@ def terminal_handle(self):
 
 if __name__ == "__main__":
 
-    if len(sys.argv) < 2:
-        print(f"Usage: python3 {sys.argv[0]} networkInterface")
-        sys.exit(-1)
 
     print("WARNING: Please ensure there are no obstacles around the robot while running this example.")
     input("Press Enter to continue...")
-
-    ChannelFactoryInitialize(0, sys.argv[1])
+    if len(sys.argv)>1:
+        ChannelFactoryInitialize(0, sys.argv[1])
+    else:
+        ChannelFactoryInitialize(0)
 
     test_option = TestOption(name=None, id=None) 
     user_interface = UserInterface()
@@ -100,7 +96,8 @@ def terminal_handle(self):
         elif test_option.id == 2:
             sport_client.StandDown()
         elif test_option.id == 3:
-            sport_client.Move(0.3,0,0)
+            ret = sport_client.Move(0.3,0,0)
+            print("ret: ",ret)
         elif test_option.id == 4:
             sport_client.Move(0,0.3,0)
         elif test_option.id == 5:
@@ -108,9 +105,9 @@ def terminal_handle(self):
         elif test_option.id == 6:
             sport_client.StopMove()
         elif test_option.id == 7:
-            sport_client.SwitchGait(0)
-        elif test_option.id == 8:
-            sport_client.SwitchGait(1)
+            sport_client.HandStand(True)
+            time.sleep(4)
+            sport_client.HandStand(False)
         elif test_option.id == 9:
             sport_client.BalanceStand()
         elif test_option.id == 10:
@@ -122,13 +119,7 @@ def terminal_handle(self):
             ret = sport_client.BackFlip()
             print("ret: ",ret)
         elif test_option.id == 13:
-            ret = sport_client.FreeWalk(True)
-            print("ret: ",ret)
-        elif test_option.id == 14:
-            ret = sport_client.FreeBound(True)
-            print("ret: ",ret)
-            time.sleep(2)
-            ret = sport_client.FreeBound(False)
+            ret = sport_client.FreeWalk()
             print("ret: ",ret)
         elif test_option.id == 14:
             ret = sport_client.FreeBound(True)
@@ -142,12 +133,6 @@ def terminal_handle(self):
             time.sleep(2)
             ret = sport_client.FreeAvoid(False)
             print("ret: ",ret)
-        elif test_option.id == 16:
-            ret = sport_client.WalkStair(True)
-            print("ret: ",ret)
-            time.sleep(10)
-            ret = sport_client.WalkStair(False)
-            print("ret: ",ret)
         elif test_option.id == 17:
             ret = sport_client.WalkUpright(True)
             print("ret: ",ret)
diff --git a/unitree_sdk2py/go2/sport/sport_api.py b/unitree_sdk2py/go2/sport/sport_api.py
index bfca62a5..2cc3cee1 100644
--- a/unitree_sdk2py/go2/sport/sport_api.py
+++ b/unitree_sdk2py/go2/sport/sport_api.py
@@ -23,46 +23,35 @@
 SPORT_API_ID_MOVE = 1008
 SPORT_API_ID_SIT = 1009
 SPORT_API_ID_RISESIT = 1010
-SPORT_API_ID_SWITCHGAIT = 1011
-SPORT_API_ID_TRIGGER = 1012
-SPORT_API_ID_BODYHEIGHT = 1013
-SPORT_API_ID_FOOTRAISEHEIGHT = 1014
 SPORT_API_ID_SPEEDLEVEL = 1015
 SPORT_API_ID_HELLO = 1016
 SPORT_API_ID_STRETCH = 1017
-SPORT_API_ID_TRAJECTORYFOLLOW = 1018
-SPORT_API_ID_CONTINUOUSGAIT = 1019
 SPORT_API_ID_CONTENT = 1020
-SPORT_API_ID_WALLOW = 1021
 SPORT_API_ID_DANCE1 = 1022
 SPORT_API_ID_DANCE2 = 1023
-SPORT_API_ID_GETBODYHEIGHT = 1024
-SPORT_API_ID_GETFOOTRAISEHEIGHT = 1025
-SPORT_API_ID_GETSPEEDLEVEL = 1026
 SPORT_API_ID_SWITCHJOYSTICK = 1027
 SPORT_API_ID_POSE = 1028
 SPORT_API_ID_SCRAPE = 1029
 SPORT_API_ID_FRONTFLIP = 1030
 SPORT_API_ID_FRONTJUMP = 1031
 SPORT_API_ID_FRONTPOUNCE = 1032
-SPORT_API_ID_WIGGLEHIPS = 1033
-SPORT_API_ID_GETSTATE = 1034
-SPORT_API_ID_ECONOMICGAIT = 1035
 SPORT_API_ID_HEART = 1036
-ROBOT_SPORT_API_ID_DANCE3             = 1037
-ROBOT_SPORT_API_ID_DANCE4             = 1038
-ROBOT_SPORT_API_ID_HOPSPINLEFT        = 1039
-ROBOT_SPORT_API_ID_HOPSPINRIGHT       = 1040
-
-ROBOT_SPORT_API_ID_LEFTFLIP           = 1042
-ROBOT_SPORT_API_ID_BACKFLIP           = 1044
-ROBOT_SPORT_API_ID_FREEWALK           = 1045
-ROBOT_SPORT_API_ID_FREEBOUND          = 1046
-ROBOT_SPORT_API_ID_FREEJUMP           = 1047
-ROBOT_SPORT_API_ID_FREEAVOID          = 1048
-ROBOT_SPORT_API_ID_WALKSTAIR          = 1049
-ROBOT_SPORT_API_ID_WALKUPRIGHT        = 1050
-ROBOT_SPORT_API_ID_CROSSSTEP          = 1051
+SPORT_API_ID_STATICWALK = 1061
+SPORT_API_ID_TROTRUN = 1062
+SPORT_API_ID_ECONOMICGAIT = 1063
+SPORT_API_ID_LEFTFLIP = 2041
+SPORT_API_ID_BACKFLIP = 2043
+SPORT_API_ID_HANDSTAND = 2044
+SPORT_API_ID_FREEWALK = 2045
+SPORT_API_ID_FREEBOUND = 2046
+SPORT_API_ID_FREEJUMP = 2047
+SPORT_API_ID_FREEAVOID = 2048
+SPORT_API_ID_CLASSICWALK = 2049
+SPORT_API_ID_WALKUPRIGHT = 2050
+SPORT_API_ID_CROSSSTEP = 2051
+SPORT_API_ID_AUTORECOVERY_SET = 2054
+SPORT_API_ID_AUTORECOVERY_GET = 2055
+SPORT_API_ID_SWITCHAVOIDMODE = 2058
 
 """
 " error code
diff --git a/unitree_sdk2py/go2/sport/sport_client.py b/unitree_sdk2py/go2/sport/sport_client.py
index d058e515..2675ab26 100644
--- a/unitree_sdk2py/go2/sport/sport_client.py
+++ b/unitree_sdk2py/go2/sport/sport_client.py
@@ -36,52 +36,45 @@ def Init(self):
         self._SetApiVerson(SPORT_API_VERSION)
         
         # regist api
-        self._RegistApi(SPORT_API_ID_DAMP, 0)
-        self._RegistApi(SPORT_API_ID_BALANCESTAND, 0)
-        self._RegistApi(SPORT_API_ID_STOPMOVE, 0)
-        self._RegistApi(SPORT_API_ID_STANDUP, 0)
-        self._RegistApi(SPORT_API_ID_STANDDOWN, 0)
-        self._RegistApi(SPORT_API_ID_RECOVERYSTAND, 0)
-        self._RegistApi(SPORT_API_ID_EULER, 0)
-        self._RegistApi(SPORT_API_ID_MOVE, 0)
-        self._RegistApi(SPORT_API_ID_SIT, 0)
-        self._RegistApi(SPORT_API_ID_RISESIT, 0)
-        self._RegistApi(SPORT_API_ID_SWITCHGAIT, 0)
-        self._RegistApi(SPORT_API_ID_TRIGGER, 0)
-        self._RegistApi(SPORT_API_ID_BODYHEIGHT, 0)
-        self._RegistApi(SPORT_API_ID_FOOTRAISEHEIGHT, 0)
-        self._RegistApi(SPORT_API_ID_SPEEDLEVEL, 0)
-        self._RegistApi(SPORT_API_ID_HELLO, 0)
-        self._RegistApi(SPORT_API_ID_STRETCH, 0)
-        self._RegistApi(SPORT_API_ID_TRAJECTORYFOLLOW, 0)
-        self._RegistApi(SPORT_API_ID_CONTINUOUSGAIT, 0)
-        # self._RegistApi(SPORT_API_ID_CONTENT, 0)
-        self._RegistApi(SPORT_API_ID_WALLOW, 0)
-        self._RegistApi(SPORT_API_ID_DANCE1, 0)
-        self._RegistApi(SPORT_API_ID_DANCE2, 0)
-        # self._RegistApi(SPORT_API_ID_GETBODYHEIGHT, 0)
-        # self._RegistApi(SPORT_API_ID_GETFOOTRAISEHEIGHT, 0)
-        # self._RegistApi(SPORT_API_ID_GETSPEEDLEVEL, 0)
-        self._RegistApi(SPORT_API_ID_SWITCHJOYSTICK, 0)
-        self._RegistApi(SPORT_API_ID_POSE, 0)
-        self._RegistApi(SPORT_API_ID_SCRAPE, 0)
-        self._RegistApi(SPORT_API_ID_FRONTFLIP, 0)
-        self._RegistApi(SPORT_API_ID_FRONTJUMP, 0)
-        self._RegistApi(SPORT_API_ID_FRONTPOUNCE, 0)
-        self._RegistApi(SPORT_API_ID_WIGGLEHIPS, 0)
-        self._RegistApi(SPORT_API_ID_GETSTATE, 0)
-        self._RegistApi(SPORT_API_ID_ECONOMICGAIT, 0)
-        self._RegistApi(SPORT_API_ID_HEART, 0)
-
-        self._RegistApi(ROBOT_SPORT_API_ID_LEFTFLIP, 0)
-        self._RegistApi(ROBOT_SPORT_API_ID_BACKFLIP, 0)
-        self._RegistApi(ROBOT_SPORT_API_ID_FREEWALK, 0)
-        self._RegistApi(ROBOT_SPORT_API_ID_FREEBOUND, 0)
-        self._RegistApi(ROBOT_SPORT_API_ID_FREEJUMP, 0)
-        self._RegistApi(ROBOT_SPORT_API_ID_FREEAVOID, 0)
-        self._RegistApi(ROBOT_SPORT_API_ID_WALKSTAIR, 0)
-        self._RegistApi(ROBOT_SPORT_API_ID_WALKUPRIGHT, 0)
-        self._RegistApi(ROBOT_SPORT_API_ID_CROSSSTEP, 0)
+        self._RegistApi(SPORT_API_ID_DAMP, 0)                  # Damp
+        self._RegistApi(SPORT_API_ID_BALANCESTAND, 0)          # BalanceStand
+        self._RegistApi(SPORT_API_ID_STOPMOVE, 0)              # StopMove
+        self._RegistApi(SPORT_API_ID_STANDUP, 0)               # StandUp
+        self._RegistApi(SPORT_API_ID_STANDDOWN, 0)             # StandDown
+        self._RegistApi(SPORT_API_ID_RECOVERYSTAND, 0)         # RecoveryStand
+        self._RegistApi(SPORT_API_ID_EULER, 0)                 # Euler
+        self._RegistApi(SPORT_API_ID_MOVE, 0)                  # Move
+        self._RegistApi(SPORT_API_ID_SIT, 0)                   # Sit
+        self._RegistApi(SPORT_API_ID_RISESIT, 0)               # RiseSit
+        self._RegistApi(SPORT_API_ID_SPEEDLEVEL, 0)            # SpeedLevel
+        self._RegistApi(SPORT_API_ID_HELLO, 0)                 # Hello
+        self._RegistApi(SPORT_API_ID_STRETCH, 0)               # Stretch
+        self._RegistApi(SPORT_API_ID_CONTENT, 0)               # Content
+        self._RegistApi(SPORT_API_ID_DANCE1, 0)                # Dance1
+        self._RegistApi(SPORT_API_ID_DANCE2, 0)                # Dance2
+        self._RegistApi(SPORT_API_ID_SWITCHJOYSTICK, 0)        # SwitchJoystick
+        self._RegistApi(SPORT_API_ID_POSE, 0)                  # Pose
+        self._RegistApi(SPORT_API_ID_SCRAPE, 0)                # Scrape
+        self._RegistApi(SPORT_API_ID_FRONTFLIP, 0)             # FrontFlip
+        self._RegistApi(SPORT_API_ID_FRONTJUMP, 0)             # FrontJump
+        self._RegistApi(SPORT_API_ID_FRONTPOUNCE, 0)           # FrontPounce
+        self._RegistApi(SPORT_API_ID_HEART, 0)                 # Heart
+        self._RegistApi(SPORT_API_ID_STATICWALK, 0)            # StaticWalk
+        self._RegistApi(SPORT_API_ID_TROTRUN, 0)               # TrotRun
+        self._RegistApi(SPORT_API_ID_ECONOMICGAIT, 0)          # EconomicGait
+        self._RegistApi(SPORT_API_ID_LEFTFLIP, 0)              # LeftFlip
+        self._RegistApi(SPORT_API_ID_BACKFLIP, 0)              # BackFlip
+        self._RegistApi(SPORT_API_ID_HANDSTAND, 0)             # HandStand
+        self._RegistApi(SPORT_API_ID_FREEWALK, 0)              # FreeWalk
+        self._RegistApi(SPORT_API_ID_FREEBOUND, 0)             # FreeBound
+        self._RegistApi(SPORT_API_ID_FREEJUMP, 0)              # FreeJump
+        self._RegistApi(SPORT_API_ID_FREEAVOID, 0)             # FreeAvoid
+        self._RegistApi(SPORT_API_ID_CLASSICWALK, 0)           # ClassicWalk
+        self._RegistApi(SPORT_API_ID_WALKUPRIGHT, 0)           # WalkUpright
+        self._RegistApi(SPORT_API_ID_CROSSSTEP, 0)             # CrossStep
+        self._RegistApi(SPORT_API_ID_AUTORECOVERY_SET, 0)      # AutoRecoverySet
+        self._RegistApi(SPORT_API_ID_AUTORECOVERY_GET, 0)      # AutoRecoveryGet
+        self._RegistApi(SPORT_API_ID_SWITCHAVOIDMODE, 0)       # SwitchAvoidMode
 
     # 1001
     def Damp(self):
@@ -159,37 +152,6 @@ def RiseSit(self):
         code, data = self._Call(SPORT_API_ID_RISESIT, parameter)
         return code
 
-    # 1011
-    def SwitchGait(self, t: int):
-        p = {}
-        p["data"] = t
-        parameter = json.dumps(p)
-        code, data = self._Call(SPORT_API_ID_SWITCHGAIT, parameter)
-        return code
-
-    # 1012
-    def Trigger(self):
-        p = {}
-        parameter = json.dumps(p)
-        code, data = self._Call(SPORT_API_ID_TRIGGER, parameter)
-        return code
-
-    # 1013
-    def BodyHeight(self, height: float):
-        p = {}
-        p["data"] = height
-        parameter = json.dumps(p)
-        code, data = self._Call(SPORT_API_ID_BODYHEIGHT, parameter)
-        return code
-
-    # 1014
-    def FootRaiseHeight(self, height: float):
-        p = {}
-        p["data"] = height
-        parameter = json.dumps(p)
-        code, data = self._Call(SPORT_API_ID_FOOTRAISEHEIGHT, parameter)
-        return code
-
     # 1015
     def SpeedLevel(self, level: int):
         p = {}
@@ -212,49 +174,11 @@ def Stretch(self):
         code, data = self._Call(SPORT_API_ID_STRETCH, parameter)
         return code
 
-    # 1018
-    def TrajectoryFollow(self, path: list):
-        l = len(path)
-        if l != SPORT_PATH_POINT_SIZE:
-            return SPORT_ERR_CLIENT_POINT_PATH
-
-        path_p = []
-        for i in range(l):
-            point = path[i]
-            p = {}
-            p["t_from_start"] = point.timeFromStart
-            p["x"] = point.x
-            p["y"] = point.y
-            p["yaw"] = point.yaw
-            p["vx"] = point.vx
-            p["vy"] = point.vy
-            p["vyaw"] = point.vyaw
-            path_p.append(p)
-            
-        parameter = json.dumps(path_p)
-        code = self._CallNoReply(SPORT_API_ID_TRAJECTORYFOLLOW, parameter)
-        return code
-
-    # 1019
-    def ContinuousGait(self, flag: int):
+    # 1020
+    def Content(self):
         p = {}
-        p["data"] = flag
         parameter = json.dumps(p)
-        code, data = self._Call(SPORT_API_ID_CONTINUOUSGAIT, parameter)
-        return code
-
-    # # 1020
-    # def Content(self):
-    #     p = {}
-    #     parameter = json.dumps(p)
-    #     code, data = self._Call(SPORT_API_ID_CONTENT, parameter)
-    #     return code
-    
-    # 1021
-    def Wallow(self):
-        p = {}
-        parameter = json.dumps(p)
-        code, data = self._Call(SPORT_API_ID_WALLOW, parameter)
+        code, data = self._Call(SPORT_API_ID_CONTENT, parameter)
         return code
 
     # 1022
@@ -271,33 +195,6 @@ def Dance2(self):
         code, data = self._Call(SPORT_API_ID_DANCE2, parameter)
         return code
 
-    # 1025
-    def GetFootRaiseHeight(self):
-        p = {}
-        parameter = json.dumps(p)
-        
-        code, data = self._Call(SPORT_API_ID_GETFOOTRAISEHEIGHT, parameter)
-        
-        if code == 0:
-            d = json.loads(data)
-            return code, d["data"]
-        else:
-            return code, None
-            
-
-    # 1026
-    def GetSpeedLevel(self):
-        p = {}
-        parameter = json.dumps(p)
-        
-        code, data = self._Call(SPORT_API_ID_GETSPEEDLEVEL, parameter)
-        
-        if code == 0:
-            d = json.loads(data)
-            return code, d["data"]
-        else:
-            return code, None
-
     # 1027
     def SwitchJoystick(self, on: bool):
         p = {}
@@ -342,30 +239,6 @@ def FrontPounce(self):
         code, data = self._Call(SPORT_API_ID_FRONTPOUNCE, parameter)
         return code
 
-    # 1033
-    def WiggleHips(self):
-        p = {}
-        parameter = json.dumps(p)
-        code, data = self._Call(SPORT_API_ID_WIGGLEHIPS, parameter)
-        return code
-
-    # 1034
-    def GetState(self, keys: list):
-        parameter = json.dumps(keys)
-        code, data = self._Call(SPORT_API_ID_GETSTATE, parameter)
-        if code == 0:
-            return code, json.loads(data)
-        else:
-            return code, None
-
-    # 1035
-    def EconomicGait(self, flag: bool):
-        p = {}
-        p["data"] = flag
-        parameter = json.dumps(p)
-        code, data = self._Call(SPORT_API_ID_ECONOMICGAIT, parameter)
-        return code
-
     # 1036
     def Heart(self):
         p = {}
@@ -373,74 +246,118 @@ def Heart(self):
         code, data = self._Call(SPORT_API_ID_HEART, parameter)
         return code
     
-    # 1042
+    # 2041
     def LeftFlip(self):
         p = {}
-        p["data"] = True
         parameter = json.dumps(p)
-        code, data = self._Call(ROBOT_SPORT_API_ID_LEFTFLIP, parameter)
+        code, data = self._Call(SPORT_API_ID_LEFTFLIP, parameter)
         return code
 
-    # 1044
+    # 2043
     def BackFlip(self):
         p = {}
-        p["data"] = True
         parameter = json.dumps(p)
-        code, data = self._Call(ROBOT_SPORT_API_ID_BACKFLIP, parameter)
+        code, data = self._Call(SPORT_API_ID_BACKFLIP, parameter)
         return code
 
-    # 1045
-    def FreeWalk(self, flag: bool):
+    # 2045
+    def FreeWalk(self):
         p = {}
-        p["data"] = True
         parameter = json.dumps(p)
-        code, data = self._Call(ROBOT_SPORT_API_ID_FREEWALK, parameter)
+        code, data = self._Call(SPORT_API_ID_FREEWALK, parameter)
         return code
 
-    # 1046
+    # 2046
     def FreeBound(self, flag: bool):
         p = {}
         p["data"] = flag
         parameter = json.dumps(p)
-        code, data = self._Call(ROBOT_SPORT_API_ID_FREEBOUND, parameter)
+        code, data = self._Call(SPORT_API_ID_FREEBOUND, parameter)
         return code
     
-    # 1047
+    # 2047
     def FreeJump(self, flag: bool):
         p = {}
         p["data"] = flag
         parameter = json.dumps(p)
-        code, data = self._Call(ROBOT_SPORT_API_ID_FREEJUMP, parameter)
+        code, data = self._Call(SPORT_API_ID_FREEJUMP, parameter)
         return code
 
-    # 1048
+    # 2048
     def FreeAvoid(self, flag: bool):
         p = {}
         p["data"] = flag
         parameter = json.dumps(p)
-        code, data = self._Call(ROBOT_SPORT_API_ID_FREEAVOID, parameter)
+        code, data = self._Call(SPORT_API_ID_FREEAVOID, parameter)
+        return code
+    
+    # 2050
+    def WalkUpright(self, flag: bool):
+        p = {}
+        p["data"] = flag
+        parameter = json.dumps(p)
+        code, data = self._Call(SPORT_API_ID_WALKUPRIGHT, parameter)
         return code
 
-    # 1049
-    def WalkStair(self, flag: bool):
+    # 2051
+    def CrossStep(self, flag: bool):  
         p = {}
         p["data"] = flag
         parameter = json.dumps(p)
-        code, data = self._Call(ROBOT_SPORT_API_ID_WALKSTAIR, parameter)
+        code, data = self._Call(SPORT_API_ID_CROSSSTEP, parameter)
         return code
     
-    # 1050
-    def WalkUpright(self, flag: bool):
+    # 1061
+    def StaticWalk(self):
+        p = {}
+        parameter = json.dumps(p)
+        code, data = self._Call(SPORT_API_ID_STATICWALK, parameter)
+        return code
+ 
+    # 1062
+    def TrotRun(self):
         p = {}
-        p["data"] = flag
         parameter = json.dumps(p)
-        code, data = self._Call(ROBOT_SPORT_API_ID_WALKUPRIGHT, parameter)
+        code, data = self._Call(SPORT_API_ID_TROTRUN, parameter)
         return code
 
-    # 1051
-    def CrossStep(self, flag: bool):  
+    # 2044
+    def HandStand(self, flag: bool):
+        p = {}
+        p["data"] = flag
+        parameter = json.dumps(p)
+        code, data = self._Call(SPORT_API_ID_HANDSTAND, parameter)
+        return code
+    # 2049
+    def ClassicWalk(self, flag: bool):
         p = {}
         p["data"] = flag
         parameter = json.dumps(p)
-        code, data = self._Call(ROBOT_SPORT_API_ID_CROSSSTEP, parameter)
-        return code
\ No newline at end of file
+        code, data = self._Call(SPORT_API_ID_CLASSICWALK, parameter)
+        return code
+
+    # 2054
+    def AutoRecoverySet(self, enabled: bool):
+        p = {}
+        p["data"] = enabled
+        parameter = json.dumps(p)
+        code, data = self._Call(SPORT_API_ID_AUTORECOVERY_SET, parameter)
+        return code
+
+    # 2055
+    def AutoRecoveryGet(self):
+        p = {}
+        parameter = json.dumps(p)
+        code, data = self._Call(SPORT_API_ID_AUTORECOVERY_GET, parameter)
+        if code == 0:
+            d = json.loads(data)
+            return code, d["data"]
+        else:
+            return code, None
+
+    # 2058
+    def SwitchAvoidMode(self):
+        p = {}
+        parameter = json.dumps(p)
+        code, data = self._Call(SPORT_API_ID_SWITCHAVOIDMODE, parameter)
+        return code