franky-control 1.0.2__cp38-cp38-manylinux_2_28_x86_64.whl → 1.1.0__cp38-cp38-manylinux_2_28_x86_64.whl

franky/__init__.py

@@ -1,12 +1,17 @@
 from .robot import Robot
-from .robot_web_session import RobotWebSession
+from .robot_web_session import (
+    RobotWebSession,
+    RobotWebSessionError,
+    FrankaAPIError,
+    TakeControlTimeoutError,
+)
 from .reaction import (
     Reaction,
     TorqueReaction,
     JointVelocityReaction,
     JointPositionReaction,
     CartesianVelocityReaction,
-    CartesianPoseReaction
+    CartesianPoseReaction,
 )
 from .motion import Motion
 from ._franky import *

franky/motion.py

@@ -1,12 +1,17 @@
 from typing import Union
 
-from ._franky import BaseCartesianPoseMotion, BaseCartesianVelocityMotion, BaseJointPositionMotion, \
-    BaseJointVelocityMotion, BaseTorqueMotion
+from ._franky import (
+    BaseCartesianPoseMotion,
+    BaseCartesianVelocityMotion,
+    BaseJointPositionMotion,
+    BaseJointVelocityMotion,
+    BaseTorqueMotion,
+)
 
 Motion = Union[
     BaseCartesianPoseMotion,
     BaseCartesianVelocityMotion,
     BaseJointPositionMotion,
     BaseJointVelocityMotion,
-    BaseTorqueMotion
+    BaseTorqueMotion,
 ]

franky/reaction.py

@@ -1,10 +1,16 @@
-from ._franky import Condition, BaseCartesianPoseMotion, BaseCartesianVelocityMotion, BaseJointPositionMotion, \
-    BaseJointVelocityMotion, BaseTorqueMotion, \
-    CartesianPoseReaction as _CartesianPoseReaction, \
-    CartesianVelocityReaction as _CartesianVelocityReaction, \
-    JointPositionReaction as _JointPositionReaction, \
-    JointVelocityReaction as _JointVelocityReaction, \
-    TorqueReaction as _TorqueReaction
+from ._franky import (
+    Condition,
+    BaseCartesianPoseMotion,
+    BaseCartesianVelocityMotion,
+    BaseJointPositionMotion,
+    BaseJointVelocityMotion,
+    BaseTorqueMotion,
+    CartesianPoseReaction as _CartesianPoseReaction,
+    CartesianVelocityReaction as _CartesianVelocityReaction,
+    JointPositionReaction as _JointPositionReaction,
+    JointVelocityReaction as _JointVelocityReaction,
+    TorqueReaction as _TorqueReaction,
+)
 
 from .motion import Motion
 
@@ -40,4 +46,9 @@ class TorqueReaction(_TorqueReaction, Reaction):
 
 
 _REACTION_TYPES = [
-    CartesianPoseReaction, CartesianVelocityReaction, JointPositionReaction, JointVelocityReaction, TorqueReaction]
+    CartesianPoseReaction,
+    CartesianVelocityReaction,
+    JointPositionReaction,
+    JointVelocityReaction,
+    TorqueReaction,
+]

franky/robot_web_session.py

@@ -7,22 +7,37 @@ import time
 import urllib.parse
 from http.client import HTTPSConnection, HTTPResponse
 from typing import Dict, Optional, Any, Literal
-from urllib.error import HTTPError
 
 
-class FrankaAPIError(Exception):
-    def __init__(self, target: str, http_code: int, http_reason: str, headers: Dict[str, str], message: str):
+class RobotWebSessionError(Exception):
+    pass
+
+
+class FrankaAPIError(RobotWebSessionError):
+    def __init__(
+        self,
+        target: str,
+        http_code: int,
+        http_reason: str,
+        headers: Dict[str, str],
+        message: str,
+    ):
         super().__init__(
-            f"Franka API returned error {http_code} ({http_reason}) when accessing end-point {target}: {message}")
+            f"Franka API returned error {http_code} ({http_reason}) when accessing end-point {target}: {message}"
+        )
         self.target = target
         self.http_code = http_code
         self.headers = headers
         self.message = message
 
 
+class TakeControlTimeoutError(RobotWebSessionError):
+    pass
+
+
 class RobotWebSession:
-    def __init__(self, fci_hostname: str, username: str, password: str):
-        self.__fci_hostname = fci_hostname
+    def __init__(self, hostname: str, username: str, password: str):
+        self.__hostname = hostname
         self.__username = username
         self.__password = password
 
@@ -33,24 +48,45 @@ class RobotWebSession:
 
     @staticmethod
     def __encode_password(user: str, password: str) -> str:
-        bs = ",".join([str(b) for b in hashlib.sha256((password + "#" + user + "@franka").encode("utf-8")).digest()])
+        bs = ",".join(
+            [
+                str(b)
+                for b in hashlib.sha256(
+                    (password + "#" + user + "@franka").encode("utf-8")
+                ).digest()
+            ]
+        )
         return base64.encodebytes(bs.encode("utf-8")).decode("utf-8")
 
-    def _send_api_request(self, target: str, headers: Optional[Dict[str, str]] = None, body: Optional[Any] = None,
-                          method: Literal["GET", "POST", "DELETE"] = "POST"):
-        _headers = {
-            "Cookie": f"authorization={self.__token}"
-        }
+    def _send_api_request(
+        self,
+        target: str,
+        headers: Optional[Dict[str, str]] = None,
+        body: Optional[Any] = None,
+        method: Literal["GET", "POST", "DELETE"] = "POST",
+    ):
+        _headers = {"Cookie": f"authorization={self.__token}"}
         if headers is not None:
             _headers.update(headers)
         self.__client.request(method, target, headers=_headers, body=body)
         res: HTTPResponse = self.__client.getresponse()
         if res.getcode() != 200:
-            raise FrankaAPIError(target, res.getcode(), res.reason, dict(res.headers), res.read().decode("utf-8"))
+            raise FrankaAPIError(
+                target,
+                res.getcode(),
+                res.reason,
+                dict(res.headers),
+                res.read().decode("utf-8"),
+            )
         return res.read()
 
-    def send_api_request(self, target: str, headers: Optional[Dict[str, str]] = None, body: Optional[Any] = None,
-                         method: Literal["GET", "POST", "DELETE"] = "POST"):
+    def send_api_request(
+        self,
+        target: str,
+        headers: Optional[Dict[str, str]] = None,
+        body: Optional[Any] = None,
+        method: Literal["GET", "POST", "DELETE"] = "POST",
+    ):
         last_error = None
         for i in range(3):
             try:
@@ -59,28 +95,38 @@ class RobotWebSession:
                 last_error = ex
         raise last_error
 
-    def send_control_api_request(self, target: str, headers: Optional[Dict[str, str]] = None,
-                                 body: Optional[Any] = None,
-                                 method: Literal["GET", "POST", "DELETE"] = "POST"):
+    def send_control_api_request(
+        self,
+        target: str,
+        headers: Optional[Dict[str, str]] = None,
+        body: Optional[Any] = None,
+        method: Literal["GET", "POST", "DELETE"] = "POST",
+    ):
         if headers is None:
             headers = {}
         self.__check_control_token()
-        _headers = {
-            "X-Control-Token": self.__control_token
-        }
+        _headers = {"X-Control-Token": self.__control_token}
         _headers.update(headers)
         return self.send_api_request(target, headers=_headers, method=method, body=body)
 
-    def open(self):
+    def open(self, timeout: float = 30.0):
         if self.is_open:
             raise RuntimeError("Session is already open.")
-        self.__client = HTTPSConnection(self.__fci_hostname, timeout=12, context=ssl._create_unverified_context())
+        self.__client = HTTPSConnection(
+            self.__hostname, timeout=timeout, context=ssl._create_unverified_context()
+        )
         self.__client.connect()
         payload = json.dumps(
-            {"login": self.__username, "password": self.__encode_password(self.__username, self.__password)})
+            {
+                "login": self.__username,
+                "password": self.__encode_password(self.__username, self.__password),
+            }
+        )
         self.__token = self.send_api_request(
-            "/admin/api/login", headers={"content-type": "application/json"},
-            body=payload).decode("utf-8")
+            "/admin/api/login",
+            headers={"content-type": "application/json"},
+            body=payload,
+        ).decode("utf-8")
         return self
 
     def close(self):
@@ -92,82 +138,125 @@ class RobotWebSession:
         self.__client.close()
 
     def __enter__(self):
-        self.open()
+        return self.open()
 
     def __exit__(self, type, value, traceback):
         self.close()
 
     def __check_control_token(self):
         if self.__control_token is None:
-            raise RuntimeError("Client does not have control. Call take_control() first.")
+            raise RuntimeError(
+                "Client does not have control. Call take_control() first."
+            )
 
-    def take_control(self, wait_timeout: float = 10.0):
-        if self.__control_token is None:
+    def take_control(self, wait_timeout: float = 30.0, force: bool = False):
+        if not self.has_control():
             res = self.send_api_request(
-                "/admin/api/control-token/request", headers={"content-type": "application/json"},
-                body=json.dumps({"requestedBy": self.__username}))
+                f"/admin/api/control-token/request{'?force' if force else ''}",
+                headers={"content-type": "application/json"},
+                body=json.dumps({"requestedBy": self.__username}),
+            )
+            if force:
+                print(
+                    "Forcibly taking control: "
+                    f"Please physically take control by pressing the top button on the FR3 within {wait_timeout}s!"
+                )
             response_dict = json.loads(res)
             self.__control_token = response_dict["token"]
             self.__control_token_id = response_dict["id"]
             # One should probably use websockets here but that would introduce another dependency
             start = time.time()
-            while time.time() - start < wait_timeout and not self.has_control():
-                time.sleep(1.0)
-        return self.has_control()
+            has_control = self.has_control()
+            while time.time() - start < wait_timeout and not has_control:
+                time.sleep(max(0.0, min(1.0, wait_timeout - (time.time() - start))))
+                has_control = self.has_control()
+            if not has_control:
+                raise TakeControlTimeoutError(
+                    f"Timed out waiting for control to be granted after {wait_timeout}s."
+                )
 
     def release_control(self):
         if self.__control_token is not None:
             self.send_control_api_request(
-                "/admin/api/control-token", headers={"content-type": "application/json"}, method="DELETE",
-                body=json.dumps({"token": self.__control_token}))
+                "/admin/api/control-token",
+                headers={"content-type": "application/json"},
+                method="DELETE",
+                body=json.dumps({"token": self.__control_token}),
+            )
             self.__control_token = None
             self.__control_token_id = None
 
     def enable_fci(self):
         self.send_control_api_request(
-            "/desk/api/system/fci", headers={"content-type": "application/x-www-form-urlencoded"},
-            body=f"token={urllib.parse.quote(base64.b64encode(self.__control_token.encode('ascii')))}")
+            "/desk/api/system/fci",
+            headers={"content-type": "application/x-www-form-urlencoded"},
+            body=f"token={urllib.parse.quote(base64.b64encode(self.__control_token.encode('ascii')))}",
+        )
 
     def has_control(self):
         if self.__control_token_id is not None:
             status = self.get_system_status()
             active_token = status["controlToken"]["activeToken"]
-            return active_token is not None and active_token["id"] == self.__control_token_id
+            return (
+                active_token is not None
+                and active_token["id"] == self.__control_token_id
+            )
         return False
 
     def start_task(self, task: str):
         self.send_api_request(
-            "/desk/api/execution", headers={"content-type": "application/x-www-form-urlencoded"},
-            body=f"id={task}")
+            "/desk/api/execution",
+            headers={"content-type": "application/x-www-form-urlencoded"},
+            body=f"id={task}",
+        )
 
     def unlock_brakes(self):
         self.send_control_api_request(
-            "/desk/api/joints/unlock", headers={"content-type": "application/x-www-form-urlencoded"})
+            "/desk/api/joints/unlock",
+            headers={"content-type": "application/x-www-form-urlencoded"},
+        )
 
     def lock_brakes(self):
         self.send_control_api_request(
-            "/desk/api/joints/lock", headers={"content-type": "application/x-www-form-urlencoded"})
+            "/desk/api/joints/lock",
+            headers={"content-type": "application/x-www-form-urlencoded"},
+        )
 
     def set_mode_programming(self):
         self.send_control_api_request(
-            "/desk/api/operating-mode/programming", headers={"content-type": "application/x-www-form-urlencoded"})
+            "/desk/api/operating-mode/programming",
+            headers={"content-type": "application/x-www-form-urlencoded"},
+        )
 
     def set_mode_execution(self):
         self.send_control_api_request(
-            "/desk/api/operating-mode/execution", headers={"content-type": "application/x-www-form-urlencoded"})
+            "/desk/api/operating-mode/execution",
+            headers={"content-type": "application/x-www-form-urlencoded"},
+        )
 
     def get_system_status(self):
-        return json.loads(self.send_api_request("/admin/api/system-status", method="GET").decode("utf-8"))
+        return json.loads(
+            self.send_api_request("/admin/api/system-status", method="GET").decode(
+                "utf-8"
+            )
+        )
 
     def execute_self_test(self):
         if self.get_system_status()["safety"]["recoverableErrors"]["td2Timeout"]:
             self.send_control_api_request(
-                "/admin/api/safety/recoverable-safety-errors/acknowledge?error_id=TD2Timeout")
-        response = json.loads(self.send_control_api_request(
-            "/admin/api/safety/td2-tests/execute", headers={"content-type": "application/json"}).decode("utf-8"))
+                "/admin/api/safety/recoverable-safety-errors/acknowledge?error_id=TD2Timeout"
+            )
+        response = json.loads(
+            self.send_control_api_request(
+                "/admin/api/safety/td2-tests/execute",
+                headers={"content-type": "application/json"},
+            ).decode("utf-8")
+        )
         assert response["code"] == "SuccessResponse"
         time.sleep(0.5)
-        while self.get_system_status()["safety"]["safetyControllerStatus"] == "SelfTest":
+        while (
+            self.get_system_status()["safety"]["safetyControllerStatus"] == "SelfTest"
+        ):
             time.sleep(0.5)
 
     @property

{franky_control-1.0.2.dist-info → franky_control-1.1.0.dist-info}/LICENSE

@@ -162,4 +162,4 @@ General Public License ever published by the Free Software Foundation.
 whether future versions of the GNU Lesser General Public License shall
 apply, that proxy's public statement of acceptance of any version is
 permanent authorization for you to choose that version for the
-Library.
+Library.

{franky_control-1.0.2.dist-info → franky_control-1.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: franky-control
-Version: 1.0.2
+Version: 1.1.0
 Summary: High-level control library for Franka robots.
 Home-page: https://github.com/TimSchneider42/franky
 Author: Tim Schneider
@@ -64,25 +64,25 @@ at [https://timschneider42.github.io/franky/](https://timschneider42.github.io/f
 
 ## 🚀 Features
 
-- **Control your Franka robot directly from Python in just a few lines!**  
+- **Control your Franka robot directly from Python in just a few lines!**
   No more endless hours setting up ROS, juggling packages, or untangling dependencies. Just `pip install` — no ROS at all.
 
-- **[Four control modes](#motion-types)**: [Cartesian position](#cartesian-position-control), [Cartesian velocity](#cartesian-velocity-control), [Joint position](#joint-position-control), [Joint velocity](#joint-velocity-control)  
+- **[Four control modes](#motion-types)**: [Cartesian position](#cartesian-position-control), [Cartesian velocity](#cartesian-velocity-control), [Joint position](#joint-position-control), [Joint velocity](#joint-velocity-control)
   Franky uses [Ruckig](https://github.com/pantor/ruckig) to generate smooth, time-optimal trajectories while respecting velocity, acceleration, and jerk limits.
 
 - **[Real-time control from Python and C++](#real-time-motions)**
   Need to change the target while the robot’s moving? No problem. Franky re-plans trajectories on the fly so that you can preempt motions anytime.
 
-- **[Reactive behavior](#-real-time-reactions)**  
+- **[Reactive behavior](#-real-time-reactions)**
   Robots don’t always go according to plan. Franky lets you define reactions to unexpected events—like contact with the environment — so you can change course in real-time.
 
-- **[Motion and reaction callbacks](#motion-callbacks)**  
+- **[Motion and reaction callbacks](#motion-callbacks)**
   Want to monitor what’s happening under the hood? Add callbacks to your motions and reactions. They won’t block the control thread and are super handy for debugging or logging.
 
-- **Things are moving too fast? [Tune the robot's dynamics to your needs](#-robot)**  
+- **Things are moving too fast? [Tune the robot's dynamics to your needs](#-robot)**
   Adjust max velocity, acceleration, and jerk to match your setup or task. Fine control for smooth, safe operation.
 
-- **Full Python access to the libfranka API**  
+- **Full Python access to the libfranka API**
   Want to tweak impedance, read the robot state, set force thresholds, or mess with the Jacobian? Go for it. If libfranka supports it, chances are Franky does, too.
 
 ## 📖 Python Quickstart Guide
@@ -262,6 +262,32 @@ docker compose run --rm franky-build run-tests  # To run the tests
 docker compose run --rm franky-build build-wheels  # To build wheels for all supported python versions
 ```
 
+### Can I use CUDA jointly with Franky?
+
+Yes. However, you need to set `IGNORE_PREEMPT_RT_PRESENCE=1` during the installation and all subsequent updates of the CUDA drivers on the real-time kernel.
+
+First, make sure that you have rebooted your system after installing the real-time kernel.
+Then, add `IGNORE_PREEMPT_RT_PRESENCE=1` to `/etc/environment`, call `export IGNORE_PREEMPT_RT_PRESENCE=1` to also set it in the current session and follow the instructions of Nvidia to install CUDA on your system.
+
+If you are on Ubuntu, you can also use [this](tools/install_cuda_realtime.bash) script to install CUDA on your real-time system:
+```bash
+# Download the script
+wget https://raw.githubusercontent.com/timschneider42/franky/master/tools/install_cuda_realtime.bash
+
+# Inspect the script to ensure it does what you expect
+
+# Make it executable
+chmod +x install_cuda_realtime.bash
+
+# Execute the script
+./install_cuda_realtime.bash
+```
+
+Alternatively, if you are a cowboy and do not care about security, you can also use this one-liner to directly call the script without checking it:
+```bash
+bash <(wget -qO- https://raw.githubusercontent.com/timschneider42/franky/master/tools/install_cuda_realtime.bash)
+```
+
 ## 📚 Tutorial
 
 Franky comes with both a C++ and Python API that differ only regarding real-time capability.
@@ -299,6 +325,8 @@ motion = CartesianMotion(Affine([0.2, 0.0, 0.0]), ReferenceType.Relative)
 robot.move(motion)
 ```
 
+Before executing any code, make sure that you have enabled the Franka Control Interface (FCI) in the Franka UI web interface.
+
 Furthermore, we will introduce methods for geometric calculations, for moving the robot according to different motion
 types, how to implement real-time reactions and changing waypoints in real time as well as controlling the gripper.
 
@@ -372,7 +400,7 @@ The robot state can be retrieved by accessing the following properties:
   obtained
   from [franka::RobotState::O_T_EE](https://frankaemika.github.io/libfranka/structfranka_1_1RobotState.html#a193781d47722b32925e0ea7ac415f442)
   and [franka::RobotState::O_dP_EE_c](https://frankaemika.github.io/libfranka/structfranka_1_1RobotState.html#a4be112bd1a9a7d777a67aea4a18a8dcc).
-* `current_joint_position`: Object of type `franky.JointState`, which contains the joint positions and velocities
+* `current_joint_state`: Object of type `franky.JointState`, which contains the joint positions and velocities
   obtained
   from [franka::RobotState::q](https://frankaemika.github.io/libfranka/structfranka_1_1RobotState.html#ade3335d1ac2f6c44741a916d565f7091)
   and [franka::RobotState::dq](https://frankaemika.github.io/libfranka/structfranka_1_1RobotState.html#a706045af1b176049e9e56df755325bd2).
@@ -418,8 +446,7 @@ and [Model](https://timschneider42.github.io/franky/classfranky_1_1_model.html)
 
 ### <a id="motion-types" /> 🏃‍♂️ Motion Types
 
-Franky currently supports four different impedance control modes: **joint position control**, **joint velocity control
-**, **cartesian position control**, and **cartesian velocity control**.
+Franky currently supports four different impedance control modes: **joint position control**, **joint velocity control**, **cartesian position control**, and **cartesian velocity control**.
 Each of these control modes is invoked by passing the robot an appropriate _Motion_ object.
 
 In the following, we provide a brief example for each motion type implemented by Franky in Python.
@@ -455,9 +482,9 @@ m_jp3 = JointWaypointMotion([
     JointWaypoint([0.1, 0.4, 0.3, -1.4, -0.3, 1.7, 0.9])
 ])
 
-# Stop the robot in joint position control mode. The difference of JointStopMotion to other stop motions such as 
-# CartesianStopMotion is that # JointStopMotion # stops the robot in joint position control mode while 
-# CartesianStopMotion stops it in cartesian pose control mode. The difference becomes relevant when asynchronous move 
+# Stop the robot in joint position control mode. The difference of JointStopMotion to other stop motions such as
+# CartesianStopMotion is that # JointStopMotion # stops the robot in joint position control mode while
+# CartesianStopMotion stops it in cartesian pose control mode. The difference becomes relevant when asynchronous move
 # commands are being sent or reactions are being used(see below).
 m_jp4 = JointStopMotion()
 ```
@@ -537,7 +564,7 @@ m_cv1 = CartesianVelocityMotion(Twist([0.2, -0.1, 0.1], [0.1, -0.1, 0.2]))
 m_cv2 = CartesianVelocityMotion(RobotVelocity(Twist([0.2, -0.1, 0.1], [0.1, -0.1, 0.2]), elbow_velocity=-0.2))
 
 # Cartesian velocity motions also support multiple waypoints. Unlike in cartesian position control, a cartesian velocity
-# waypoint is a target velocity to be reached. This particular example first accelerates the end-effector, holds the 
+# waypoint is a target velocity to be reached. This particular example first accelerates the end-effector, holds the
 # velocity for 1s, then # reverses direction for 2s, reverses direction again for 1s, and finally stops. It is important
 # not to forget to stop # the robot at the end of such a sequence, as it will otherwise throw an error.
 m_cv4 = CartesianVelocityWaypointMotion([
@@ -580,7 +607,7 @@ robot.relative_dynamics_factor = RelativeDynamicsFactor(0.05, 0.1, 0.15)
 
 robot.move(m_jp1)
 
-# We can also set a relative dynamics factor in the move command. It will be multiplied with the other relative 
+# We can also set a relative dynamics factor in the move command. It will be multiplied with the other relative
 # dynamics factors (robot and motion if present).
 robot.move(m_jp2, relative_dynamics_factor=0.8)
 ```
@@ -705,7 +732,7 @@ motion
         }),
       [](const franka::RobotState& state, double rel_time, double abs_time) {
         // Lambda reaction motion generator
-        // (we are just returning a stop motion, but there could be arbitrary 
+        // (we are just returning a stop motion, but there could be arbitrary
         // logic here for generating reaction motions)
         return StopMotion<franka::CartesianPose>();
       })
@@ -750,7 +777,7 @@ The next time `Robot.join_motion` or `Robot.move` are called, they will throw th
 Hence, after an asynchronous motion has finished, make sure to call `Robot.join_motion` to ensure being notified of any
 exceptions that occurred during the motion.
 
-### Gripper
+### <a id="gripper" /> 👌  Gripper
 
 In the `franky::Gripper` class, the default gripper force and gripper speed can be set.
 Then, additionally to the libfranka commands, the following helper methods can be used:
@@ -825,6 +852,80 @@ else:
     print("Gripper motion timed out.")
 ```
 
+### Accessing the Web Interface API
+
+For Franka robots, control happens via the Franka Control Interface (FCI), which has to be enabled through the Franka UI in the robot's web interface.
+The Franka UI also provides methods for locking and unlocking the brakes, setting the execution mode, and executing the safety self-test.
+However, sometimes you may want to access these methods programmatically, e.g. for automatically unlocking the brakes before starting a motion, or automatically executing the self-test after 24h of continuous execution.
+
+For that reason, Franky provides a `RobotWebSession` class that allows you to access the web interface API of the robot.
+Note that directly accessing the web interface API is not officially supported and documented by Franka.
+Hence, use this feature at your own risk.
+
+A typical automated workflow could look like this:
+
+```python
+import franky
+
+with franky.RobotWebSession("172.16.0.2", "username", "password") as robot_web_session:
+    # First take control
+    try:
+        # Try taking control. The session currently holding control has to release it in order for this session to gain
+        # control. In the web interface, a notification will show prompting the user to release control. If the other
+        # session is another franky.RobotWebSession, then the `release_control` method can be called on the other
+        # session to release control.
+        robot_web_session.take_control(wait_timeout=10.0)
+    except franky.TakeControlTimeoutError:
+        # If nothing happens for 10s, we try to take control forcefully. This is particularly useful if the session
+        # holding control is dead. Taking control by force requires the user to manually push the blue button close to
+        # the robot's wrist.
+        robot_web_session.take_control(wait_timeout=30.0, force=True)
+
+    # Unlock the brakes
+    robot_web_session.unlock_brakes()
+
+    # Enable the FCI
+    robot_web_session.enable_fci()
+
+    # Create a franky.Robot instance and do whatever you want
+    ...
+
+    # Disable the FCI
+    robot_web_session.disable_fci()
+
+    # Lock brakes
+    robot_web_session.lock_brakes()
+```
+
+In case you are running the robot for longer than 24h you will have noticed that you have to do a safety self-test every 24h.
+`RobotWebSession` allows to automate this task as well:
+
+```python
+import time
+import franky
+
+with franky.RobotWebSession("172.16.0.2", "username", "password") as robot_web_session:
+    # Execute self-test if the time until self-test is less than 5 minutes.
+    if robot_web_session.get_system_status()["safety"]["timeToTd2"] < 300:
+        robot_web_session.disable_fci()
+        robot_web_session.lock_brakes()
+        time.sleep(1.0)
+
+        robot_web_session.execute_self_test()
+
+        robot_web_session.unlock_brakes()
+        robot_web_session.enable_fci()
+        time.sleep(1.0)
+
+        # Recreate your franky.Robot instance as the FCI has been disabled and re-enabled
+        ...
+```
+
+`robot_web_session.get_system_status()` contains more information than just the time until self-test, such as the current execution mode, whether the brakes are locked, whether the FCI is enabled, and more.
+
+If you want to call other API functions, you can use the `RobotWebSession.send_api_request` and `RobotWebSession.send_control_api_request` methods.
+See [robot_web_session.py](franky/robot_web_session.py) for an example of how to use these methods.
+
 ## 🛠️ Development
 
 Franky is currently tested against following versions
@@ -867,3 +968,12 @@ Aside of bug fixes and general performance improvements, Franky provides the fol
 * Franky supports [joint velocity control](#joint-velocity-control)
   and [cartesian velocity control](#cartesian-velocity-control)
 * The dynamics limits are not hard-coded anymore but can be [set for each robot instance](#-robot).
+
+## Contributing
+
+If you wish to contribute to this project, you are welcome to create a pull request.
+Please run the [pre-commit](https://pre-commit.com/) hooks before submitting your pull request.
+To install the pre-commit hooks, run:
+
+1. [Install pre-commit](https://pre-commit.com/#install)
+2. Install the Git hooks by running `pre-commit install` or, alternatively, run `pre-commit run --all-files manually.

franky_control-1.1.0.dist-info/RECORD

@@ -0,0 +1,27 @@
+franky/__init__.py,sha256=57BsmUytdeqMrhHglwvxMS6CgpAEVPw0KJge8_UTzEA,378
+franky/_franky.cpython-38-x86_64-linux-gnu.so,sha256=tXot0qHR2SFT86v8m40olQ4uAUSfWkPxftaR_e1BdTc,3075809
+franky/_franky.pyi,sha256=odBnBaM2qGN4mUa8WvFN5SL9aszPgDTsZj5Jb9UkFHk,60047
+franky/motion.py,sha256=TWsx2Ba9iYG9e-OxpuYZlVn1wdzKS-Zvz6ayHT_HYXQ,354
+franky/reaction.py,sha256=cBuHAMek9yH-9Zmwfa0dzz2t5G_1SQEWXNdW7mhhCI8,1519
+franky/robot.py,sha256=NaTNh4PaJshbz44eibvLCMt6O_Ak7TRVjhUR6AGay9A,236
+franky/robot_web_session.py,sha256=rYpnUe4b8xj5JjCYxNRZ0uYz8lL2qfxKglcImFDw24Y,9070
+franky_control.libs/libPocoFoundation-91a48101.so.95,sha256=ayW6qwws-4x4I7Ee3WK4LRRAyaQuTvbGuEBTkjZy7CU,3273833
+franky_control.libs/libPocoNet-9e586dc9.so.95,sha256=KQ6mL1nO9NlXzpp7NcBAKLxC9vjzNd_l9Jy8ldXlotU,2504833
+franky_control.libs/libboost_filesystem-38deced9.so.1.66.0,sha256=-thu-LYmEDUKnOhQw3njV9C58dVZV12pn_6-KoqDCeI,145241
+franky_control.libs/libboost_serialization-3aa46b41.so.1.66.0,sha256=KpSA9K4iakzd-Mvv5JvPSqxJyMYsVkcIXrUbSlAkiIo,316673
+franky_control.libs/libboost_system-69a6c43e.so.1.66.0,sha256=sd_lA0coUWXm-bluxkOkNrzrxFSAXYDphjPDwBekik8,22905
+franky_control.libs/libconsole_bridge-def124d9.so.0.3,sha256=Eg1wJzVIRG5GQhyr59_qdYgnmhto0orU0j8HW2A0JIg,27297
+franky_control.libs/libfmt-8375f6bf.so.6.2.1,sha256=Z8D_NYG4rsuwMIYP3KfNB95w7vnsPaV5XLm2EnWd9Fk,327441
+franky_control.libs/libfranka-92ddaf43.so.0.15.0,sha256=pVavBW1460_MHqwSDTbwkE5vUfGTOi2PnZjSVQRvwOY,1145681
+franky_control.libs/libpinocchio_default-53a889f9.so.3.1.0,sha256=1us8TU8dwRDiCeB-sUnSx2w_Czcr7E-QC21VVO_ht0g,9255841
+franky_control.libs/libpinocchio_parsers-a0902fb5.so.3.1.0,sha256=hsF6GO3VBJu034O1PxRlQSTyGmFKaEdO1_lN7Z3bbgM,713129
+franky_control.libs/libtinyxml-435d1f53.so.0.2.6.2,sha256=BGSkG-zXEYTuGquHhydNow2ufOetDZpEP7MbBZyf6hA,120209
+franky_control.libs/liburdfdom_model-9e7b5a88.so.1.0,sha256=c4cAZ09SHlu-dpMZmwsxC8Ydklm8RzEANxvdJHeh4Ho,187561
+franky_control.libs/liburdfdom_model_state-741cbb83.so.1.0,sha256=NvqLfm2u-YlCihr5GRoUGL6iJMLRHm-RFEmR0he5csM,59105
+franky_control.libs/liburdfdom_sensor-5dbb5bb4.so.1.0,sha256=udrHZ0oYFTf9qwr8hm8rSrBKZDkd1L5yy5tyh10D018,51777
+franky_control.libs/liburdfdom_world-bd943329.so.1.0,sha256=ja9WE45nXtAGUoLpg1T1Hte8BZLldj_WNf9cL3H1RPk,187561
+franky_control-1.1.0.dist-info/LICENSE,sha256=2n6rt7r999OuXp8iOqW9we7ORaxWncIbOwN1ILRGR2g,7651
+franky_control-1.1.0.dist-info/METADATA,sha256=tY2cwf3m5RF0BLL6f5MlP4GC-huOPAImMbvIP4NU0wg,40066
+franky_control-1.1.0.dist-info/WHEEL,sha256=4bDjsNqNiwr2G2bLNR18ftAr5l4l03O656kYhb6U22c,111
+franky_control-1.1.0.dist-info/top_level.txt,sha256=LdDKRvHTODs6ll6Ow5b-gmWqt4NJffHxL83MRTCv_Ag,22
+franky_control-1.1.0.dist-info/RECORD,,

franky_control-1.0.2.dist-info/RECORD

@@ -1,27 +0,0 @@
-franky/__init__.py,sha256=lmRG8cc4eX-0gZgCkxxVCOrmuUEGJsppWl7DDURib-Y,293
-franky/_franky.cpython-38-x86_64-linux-gnu.so,sha256=N4Suzx4a9DnK4LqFYHqw9UuzbVhoqS6OqPzyMvL1n8Y,3075809
-franky/_franky.pyi,sha256=odBnBaM2qGN4mUa8WvFN5SL9aszPgDTsZj5Jb9UkFHk,60047
-franky/motion.py,sha256=EZmZPvu2r4YBhcokV1PFh8s8NmiwOUERvct3Zz629C8,334
-franky/reaction.py,sha256=gDD7kVc_7Et2NwMmCB4Hcd12aK0eygJVqXzZ9Dzw0_M,1488
-franky/robot.py,sha256=NaTNh4PaJshbz44eibvLCMt6O_Ak7TRVjhUR6AGay9A,236
-franky/robot_web_session.py,sha256=zOTAqDF4PbZLqJFr3RcuBwfWRSEMiw0Eag1stk3GWKE,7622
-franky_control.libs/libPocoFoundation-7333b9fc.so.95,sha256=uWvz8wEhtptpIfCJH1nPOe5YC8I-ErEPjDn1uLJO6jo,3273833
-franky_control.libs/libPocoNet-007a41b7.so.95,sha256=ID59zS7O1bSBlCF9MZOHyy6n0AcfbLgfHJbSn5QZB60,2504833
-franky_control.libs/libboost_filesystem-38deced9.so.1.66.0,sha256=-thu-LYmEDUKnOhQw3njV9C58dVZV12pn_6-KoqDCeI,145241
-franky_control.libs/libboost_serialization-3aa46b41.so.1.66.0,sha256=KpSA9K4iakzd-Mvv5JvPSqxJyMYsVkcIXrUbSlAkiIo,316673
-franky_control.libs/libboost_system-69a6c43e.so.1.66.0,sha256=sd_lA0coUWXm-bluxkOkNrzrxFSAXYDphjPDwBekik8,22905
-franky_control.libs/libconsole_bridge-def124d9.so.0.3,sha256=Eg1wJzVIRG5GQhyr59_qdYgnmhto0orU0j8HW2A0JIg,27297
-franky_control.libs/libfmt-8375f6bf.so.6.2.1,sha256=Z8D_NYG4rsuwMIYP3KfNB95w7vnsPaV5XLm2EnWd9Fk,327441
-franky_control.libs/libfranka-92ddaf43.so.0.15.0,sha256=lGXhCXAtQnDYzJpz2Jf6tOhBN-0CSaTmVxs9I1p7afo,1145681
-franky_control.libs/libpinocchio_default-7b0164b0.so.3.1.0,sha256=vHyDT_5YG6YigVJsdaSnC6FApzePbWbRn2gji5rwZtM,9255841
-franky_control.libs/libpinocchio_parsers-50abb87c.so.3.1.0,sha256=46UjCQRT010QVmWFwfddGHr3knuBw3Xcsc09Bw5aLIM,713129
-franky_control.libs/libtinyxml-435d1f53.so.0.2.6.2,sha256=BGSkG-zXEYTuGquHhydNow2ufOetDZpEP7MbBZyf6hA,120209
-franky_control.libs/liburdfdom_model-9e7b5a88.so.1.0,sha256=c4cAZ09SHlu-dpMZmwsxC8Ydklm8RzEANxvdJHeh4Ho,187561
-franky_control.libs/liburdfdom_model_state-741cbb83.so.1.0,sha256=NvqLfm2u-YlCihr5GRoUGL6iJMLRHm-RFEmR0he5csM,59105
-franky_control.libs/liburdfdom_sensor-5dbb5bb4.so.1.0,sha256=udrHZ0oYFTf9qwr8hm8rSrBKZDkd1L5yy5tyh10D018,51777
-franky_control.libs/liburdfdom_world-bd943329.so.1.0,sha256=ja9WE45nXtAGUoLpg1T1Hte8BZLldj_WNf9cL3H1RPk,187561
-franky_control-1.0.2.dist-info/LICENSE,sha256=6or154nLLU6bELzjh0mCreFjt0m2v72zLi3yHE0QbeE,7650
-franky_control-1.0.2.dist-info/METADATA,sha256=8w7ITX99ftSyZ4TTdgcZ8fxgYC0_UsNfzcbgatWPK-4,34881
-franky_control-1.0.2.dist-info/WHEEL,sha256=4bDjsNqNiwr2G2bLNR18ftAr5l4l03O656kYhb6U22c,111
-franky_control-1.0.2.dist-info/top_level.txt,sha256=LdDKRvHTODs6ll6Ow5b-gmWqt4NJffHxL83MRTCv_Ag,22
-franky_control-1.0.2.dist-info/RECORD,,