wirepod-vector-sdk-audio 0.9.0__py3-none-any.whl

anki_vector/screen.py

@@ -0,0 +1,201 @@
+# Copyright (c) 2018 Anki, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License in the file LICENSE.txt or at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Vector's LCD Screen that displays his face.
+
+The screen is 184 x 96 color (RGB565) pixels. The active area is 23.2mm x 12.1mm.
+"""
+
+# __all__ should order by constants, event classes, other classes, functions.
+__all__ = ['dimensions', 'convert_image_to_screen_data',
+           'convert_pixels_to_screen_data', 'ScreenComponent']
+
+import sys
+
+from . import color, connection, util
+from .messaging import protocol
+
+try:
+    from PIL import Image
+except ImportError:
+    sys.exit("Cannot import from PIL: Do `pip3 install --user Pillow` to install")
+
+SCREEN_WIDTH = 184
+SCREEN_HEIGHT = 96
+
+
+def dimensions():
+    """Return the dimension (width, height) of the Screen.
+
+    .. testcode::
+
+        import anki_vector
+
+        screen_dimensions = anki_vector.screen.SCREEN_WIDTH, anki_vector.screen.SCREEN_HEIGHT
+
+    Returns:
+        A tuple of ints (width, height)
+    """
+    return SCREEN_WIDTH, SCREEN_HEIGHT
+
+
+def convert_pixels_to_screen_data(pixel_data: list, image_width: int, image_height: int):
+    """Convert a sequence of pixel data to the correct format to display on Vector's face.
+
+    :param pixel_data: sequence of triplets representing rgb values, should be ints from 0-255
+    :param image_width: width of the image defined by the pixel_data
+    :param image_height: height of the image defined by the pixel_data
+
+    .. testcode::
+
+        import anki_vector
+        from anki_vector.screen import convert_pixels_to_screen_data
+        from PIL import Image
+
+        image_file = Image.open('../examples/face_images/cozmo_image.jpg')
+        image_data = image_file.getdata()
+        pixel_bytes = convert_pixels_to_screen_data(image_data, image_file.width, image_file.height)
+
+    Returns:
+        A :class:`bytes` object representing all of the pixels (16bit color in rgb565 format)
+
+    Raises:
+        ValueError: Invalid Dimensions
+        ValueError: Bad image_width
+        ValueError: Bad image_height
+    """
+    if len(pixel_data) != (image_width * image_height):
+        raise ValueError('Invalid Dimensions: len(pixel_data) {0} != image_width={1} * image_height={2} (== {3})'. format(len(pixel_data),
+                                                                                                                          image_width,
+                                                                                                                          image_height,
+                                                                                                                          image_width *
+                                                                                                                          image_height))
+
+    # @TODO: We should decide on a resampling approach and have this function automatically rescale images
+    #  We should either enforce the aspect ratio, or have options to:
+    #  - automatically crop to the proper aspect ratio
+    #  - stretch to fit
+    #  - shrink to fit with margins some default color
+    if image_width != SCREEN_WIDTH:
+        raise ValueError('Bad image_width: image_width {0} must be the resolution width: {1}'. format(image_width, SCREEN_WIDTH))
+
+    if image_height != SCREEN_HEIGHT:
+        raise ValueError('Bad image_height: image_height {0} must be the resolution height: {1}'. format(image_height, SCREEN_HEIGHT))
+
+    color_565_data = []
+    for color_tuple in pixel_data:
+        color_object = color.Color(rgb=color_tuple)
+        color_565_data.extend(color_object.rgb565_bytepair)
+
+    return bytes(color_565_data)
+
+
+def convert_image_to_screen_data(pil_image: Image.Image):
+    """Convert an image into the correct format to display on Vector's face.
+
+    .. testcode::
+
+        import anki_vector
+
+        try:
+            from PIL import Image
+        except ImportError:
+            sys.exit("Cannot import from PIL: Do `pip3 install --user Pillow` to install")
+
+        with anki_vector.Robot() as robot:
+            # Load an image
+            image_file = Image.open('../examples/face_images/cozmo_image.jpg')
+
+            # Convert the image to the format used by the Screen
+            screen_data = anki_vector.screen.convert_image_to_screen_data(image_file)
+            robot.screen.set_screen_with_image_data(screen_data, 4.0)
+
+    :param pil_image: The image to display on Vector's face
+
+    Returns:
+        A :class:`bytes` object representing all of the pixels (16bit color in rgb565 format)
+    """
+    image_data = pil_image.getdata()
+
+    return convert_pixels_to_screen_data(image_data, pil_image.width, pil_image.height)
+
+
+class ScreenComponent(util.Component):
+    """Handles messaging to control Vector's screen"""
+
+    @connection.on_connection_thread(log_messaging=False)
+    async def set_screen_with_image_data(self, image_data: bytes, duration_sec: float, interrupt_running: bool = True):
+        """
+        Display an image on Vector's Screen (his "face").
+
+        .. testcode::
+
+            import anki_vector
+            import time
+
+            try:
+                from PIL import Image
+            except ImportError:
+                sys.exit("Cannot import from PIL: Do `pip3 install --user Pillow` to install")
+
+            with anki_vector.Robot() as robot:
+                # Load an image
+                image_file = Image.open('../examples/face_images/cozmo_image.jpg')
+
+                # Convert the image to the format used by the Screen
+                screen_data = anki_vector.screen.convert_image_to_screen_data(image_file)
+
+                duration_s = 4.0
+                robot.screen.set_screen_with_image_data(screen_data, duration_s)
+                time.sleep(duration_s)
+
+        :param image_data: A :class:`bytes` object representing all of the pixels (16bit color in rgb565 format)
+        :param duration_sec: The number of seconds the image should remain on Vector's face.
+        :param interrupt_running: Set to true so any currently-streaming animation will be aborted in favor of this.
+        """
+        if not isinstance(image_data, bytes):
+            raise ValueError("set_screen_with_image_data expected bytes")
+        if len(image_data) != 35328:
+            raise ValueError("set_screen_with_image_data expected 35328 bytes - (2 bytes each for 17664 pixels)")
+
+        # Generate the message
+        message = protocol.DisplayFaceImageRGBRequest()
+        # Create byte array at the Screen resolution
+        message.face_data = image_data
+        message.duration_ms = int(1000 * duration_sec)
+        message.interrupt_running = interrupt_running
+
+        return await self.grpc_interface.DisplayFaceImageRGB(message)
+
+    def set_screen_to_color(self, solid_color: color.Color, duration_sec: float, interrupt_running: bool = True):
+        """
+        Set Vector's Screen (his "face"). to a solid color.
+
+        .. testcode::
+
+            import anki_vector
+            import time
+
+            with anki_vector.Robot() as robot:
+                duration_s = 4.0
+                robot.screen.set_screen_to_color(anki_vector.color.Color(rgb=[255, 128, 0]), duration_sec=duration_s)
+                time.sleep(duration_s)
+
+        :param solid_color: Desired color to set Vector's Screen.
+        :param duration_sec: The number of seconds the color should remain on Vector's face.
+        :param interrupt_running: Set to true so any currently-streaming animation will be aborted in favor of this.
+        """
+        image_data = bytes(solid_color.rgb565_bytepair * 17664)
+        return self.set_screen_with_image_data(image_data, duration_sec, interrupt_running)

anki_vector/status.py

@@ -0,0 +1,322 @@
+# Copyright (c) 2018 Anki, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License in the file LICENSE.txt or at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+.. _status:
+
+Robot Status class and exposed properties for Vector's various states.
+
+The :class:`RobotStatus` class in this module exposes properties
+about the robot status like :py:attr:`is_charging <RobotStatus.is_charging>`,
+:py:attr:`is_being_held <RobotStatus.is_being_held>`, etc.
+"""
+
+# __all__ should order by constants, event classes, other classes, functions.
+__all__ = ['ROBOT_STATUS_NONE', 'ROBOT_STATUS_ARE_MOTORS_MOVING', 'ROBOT_STATUS_IS_CARRYING_BLOCK',
+           'ROBOT_STATUS_IS_DOCKING_TO_MARKER', 'ROBOT_STATUS_IS_PICKED_UP', 'ROBOT_STATUS_IS_BUTTON_PRESSED',
+           'ROBOT_STATUS_IS_FALLING', 'ROBOT_STATUS_IS_ANIMATING', 'ROBOT_STATUS_IS_PATHING',
+           'ROBOT_STATUS_LIFT_IN_POS', 'ROBOT_STATUS_HEAD_IN_POS', 'ROBOT_STATUS_CALM_POWER_MODE',
+           'ROBOT_STATUS_IS_ON_CHARGER', 'ROBOT_STATUS_IS_CHARGING', 'ROBOT_STATUS_CLIFF_DETECTED',
+           'ROBOT_STATUS_ARE_WHEELS_MOVING', 'ROBOT_STATUS_IS_BEING_HELD', 'ROBOT_STATUS_IS_ROBOT_MOVING',
+           'RobotStatus']
+
+from . import util
+from .messaging import protocol
+
+ROBOT_STATUS_NONE = protocol.RobotStatus.Value("ROBOT_STATUS_NONE")
+ROBOT_STATUS_ARE_MOTORS_MOVING = protocol.RobotStatus.Value("ROBOT_STATUS_IS_MOVING")
+ROBOT_STATUS_IS_CARRYING_BLOCK = protocol.RobotStatus.Value("ROBOT_STATUS_IS_CARRYING_BLOCK")
+ROBOT_STATUS_IS_DOCKING_TO_MARKER = protocol.RobotStatus.Value("ROBOT_STATUS_IS_PICKING_OR_PLACING")
+ROBOT_STATUS_IS_PICKED_UP = protocol.RobotStatus.Value("ROBOT_STATUS_IS_PICKED_UP")
+ROBOT_STATUS_IS_BUTTON_PRESSED = protocol.RobotStatus.Value("ROBOT_STATUS_IS_BUTTON_PRESSED")
+ROBOT_STATUS_IS_FALLING = protocol.RobotStatus.Value("ROBOT_STATUS_IS_FALLING")
+ROBOT_STATUS_IS_ANIMATING = protocol.RobotStatus.Value("ROBOT_STATUS_IS_ANIMATING")
+ROBOT_STATUS_IS_PATHING = protocol.RobotStatus.Value("ROBOT_STATUS_IS_PATHING")
+ROBOT_STATUS_LIFT_IN_POS = protocol.RobotStatus.Value("ROBOT_STATUS_LIFT_IN_POS")
+ROBOT_STATUS_HEAD_IN_POS = protocol.RobotStatus.Value("ROBOT_STATUS_HEAD_IN_POS")
+ROBOT_STATUS_CALM_POWER_MODE = protocol.RobotStatus.Value("ROBOT_STATUS_CALM_POWER_MODE")
+ROBOT_STATUS_IS_ON_CHARGER = protocol.RobotStatus.Value("ROBOT_STATUS_IS_ON_CHARGER")
+ROBOT_STATUS_IS_CHARGING = protocol.RobotStatus.Value("ROBOT_STATUS_IS_CHARGING")
+ROBOT_STATUS_CLIFF_DETECTED = protocol.RobotStatus.Value("ROBOT_STATUS_CLIFF_DETECTED")
+ROBOT_STATUS_ARE_WHEELS_MOVING = protocol.RobotStatus.Value("ROBOT_STATUS_ARE_WHEELS_MOVING")
+ROBOT_STATUS_IS_BEING_HELD = protocol.RobotStatus.Value("ROBOT_STATUS_IS_BEING_HELD")
+ROBOT_STATUS_IS_ROBOT_MOVING = protocol.RobotStatus.Value("ROBOT_STATUS_IS_MOTION_DETECTED")
+
+
+class RobotStatus():
+    """A class to expose various status properties of the robot."""
+
+    def __init__(self):
+        # Default robot status
+        self._status: int = None
+
+    def set(self, status: int):
+        self._status = status
+
+    @util.block_while_none()
+    def __get(self) -> int:
+        return self._status
+
+    @property
+    def are_motors_moving(self) -> bool:
+        """True if Vector is currently moving any of his motors (head, arm or
+        wheels/treads).
+
+        .. testcode::
+
+            import anki_vector
+
+            with anki_vector.Robot() as robot:
+                if robot.status.are_motors_moving:
+                    print("Vector is moving.")
+        """
+        return (self.__get() & ROBOT_STATUS_ARE_MOTORS_MOVING) != 0
+
+    @property
+    def is_carrying_block(self) -> bool:
+        """True if Vector is currently carrying a block.
+
+        .. testcode::
+
+            import anki_vector
+
+            with anki_vector.Robot() as robot:
+                if robot.status.is_carrying_block:
+                    print("Vector is carrying his block.")
+        """
+        return (self.__get() & ROBOT_STATUS_IS_CARRYING_BLOCK) != 0
+
+    @property
+    def is_docking_to_marker(self) -> bool:
+        """True if Vector has seen a marker and is actively heading toward it
+        (for example his charger or cube).
+
+        .. testcode::
+
+            import anki_vector
+
+            with anki_vector.Robot() as robot:
+                if robot.status.is_docking_to_marker:
+                    print("Vector has found a marker and is docking to it.")
+        """
+        return (self.__get() & ROBOT_STATUS_IS_DOCKING_TO_MARKER) != 0
+
+    @property
+    def is_picked_up(self) -> bool:
+        """True if Vector is currently picked up (in the air).
+
+        If :py:attr:`is_being_held` is true, then :py:attr:`is_picked_up` is always True.
+
+        :py:attr:`is_picked_up` uses the IMU data to determine if the robot is not on a stable surface with his treads down.
+        If the robot is on its side, :py:attr:`is_picked_up` is True.
+
+        .. testcode::
+
+            import anki_vector
+
+            with anki_vector.Robot() as robot:
+                if robot.status.is_picked_up:
+                    print("Vector is picked up.")
+        """
+        return (self.__get() & ROBOT_STATUS_IS_PICKED_UP) != 0
+
+    @property
+    def is_button_pressed(self) -> bool:
+        """True if Vector's button is pressed.
+
+        .. testcode::
+
+            import anki_vector
+
+            with anki_vector.Robot() as robot:
+                if robot.status.is_button_pressed:
+                    print("Vector's button was button pressed.")
+        """
+        return (self.__get() & ROBOT_STATUS_IS_BUTTON_PRESSED) != 0
+
+    @property
+    def is_falling(self) -> bool:
+        """True if Vector is currently falling.
+
+        .. testcode::
+
+            import anki_vector
+
+            with anki_vector.Robot() as robot:
+                if robot.status.is_falling:
+                    print("Vector is falling.")
+        """
+        return (self.__get() & ROBOT_STATUS_IS_FALLING) != 0
+
+    @property
+    def is_animating(self) -> bool:
+        """True if Vector is currently playing an animation.
+
+        .. testcode::
+
+            import anki_vector
+
+            with anki_vector.Robot() as robot:
+                if robot.status.is_animating:
+                    print("Vector is animating.")
+        """
+        return (self.__get() & ROBOT_STATUS_IS_ANIMATING) != 0
+
+    @property
+    def is_pathing(self) -> bool:
+        """True if Vector is currently traversing a path.
+
+        .. testcode::
+
+            import anki_vector
+
+            with anki_vector.Robot() as robot:
+                if robot.status.is_pathing:
+                    print("Vector is traversing a path.")
+        """
+        return (self.__get() & ROBOT_STATUS_IS_PATHING) != 0
+
+    @property
+    def is_lift_in_pos(self) -> bool:
+        """True if Vector's arm is in the desired position (False if still
+        trying to move it there).
+
+        .. testcode::
+
+            import anki_vector
+
+            with anki_vector.Robot() as robot:
+                if robot.status.is_lift_in_pos:
+                    print("Vector's arm is in position.")
+        """
+        return (self.__get() & ROBOT_STATUS_LIFT_IN_POS) != 0
+
+    @property
+    def is_head_in_pos(self) -> bool:
+        """True if Vector's head is in the desired position (False if still
+        trying to move there).
+
+        .. testcode::
+
+            import anki_vector
+
+            with anki_vector.Robot() as robot:
+                if robot.status.is_head_in_pos:
+                    print("Vector's head is in position.")
+        """
+        return (self.__get() & ROBOT_STATUS_HEAD_IN_POS) != 0
+
+    @property
+    def is_in_calm_power_mode(self) -> bool:
+        """True if Vector is in calm power mode.  Calm power mode is generally
+        when Vector is sleeping or charging.
+
+        .. testcode::
+
+            import anki_vector
+
+            with anki_vector.Robot() as robot:
+                if robot.status.is_in_calm_power_mode:
+                    print("Vector is in calm power mode.")
+        """
+        return (self.__get() & ROBOT_STATUS_CALM_POWER_MODE) != 0
+
+    @property
+    def is_on_charger(self) -> bool:
+        """True if Vector is currently on the charger.
+
+        .. testcode::
+
+            import anki_vector
+
+            with anki_vector.Robot() as robot:
+                if robot.status.is_on_charger:
+                    print("Vector is on the charger.")
+        """
+        return (self.__get() & ROBOT_STATUS_IS_ON_CHARGER) != 0
+
+    @property
+    def is_charging(self) -> bool:
+        """True if Vector is currently charging.
+
+        .. testcode::
+
+            import anki_vector
+
+            with anki_vector.Robot() as robot:
+                if robot.status.is_charging:
+                    print("Vector is currently charging.")
+        """
+        return (self.__get() & ROBOT_STATUS_IS_CHARGING) != 0
+
+    @property
+    def is_cliff_detected(self) -> bool:
+        """True if Vector detected a cliff using any of his four cliff sensors.
+
+        .. testcode::
+
+            import anki_vector
+
+            with anki_vector.Robot() as robot:
+                if robot.status.is_cliff_detected:
+                    print("Vector has detected a cliff.")
+        """
+        return (self.__get() & ROBOT_STATUS_CLIFF_DETECTED) != 0
+
+    @property
+    def are_wheels_moving(self) -> bool:
+        """True if Vector's wheels/treads are currently moving.
+
+        .. testcode::
+
+            import anki_vector
+
+            with anki_vector.Robot() as robot:
+                if robot.status.are_wheels_moving:
+                    print("Vector's wheels are moving.")
+        """
+        return (self.__get() & ROBOT_STATUS_ARE_WHEELS_MOVING) != 0
+
+    @property
+    def is_being_held(self) -> bool:
+        """True if Vector is being held.
+
+        :py:attr:`is_being_held` uses the IMU to look for tiny motions
+        that suggest the robot is actively being held in someone's hand.
+
+        .. testcode::
+
+            import anki_vector
+
+            with anki_vector.Robot() as robot:
+                if robot.status.is_being_held:
+                    print("Vector is being held.")
+        """
+        return (self.__get() & ROBOT_STATUS_IS_BEING_HELD) != 0
+
+    @property
+    def is_robot_moving(self) -> bool:
+        """True if Vector is in motion.  This includes any of his motors
+        (head, arm, wheels/tracks) and if he is being lifted, carried,
+        or falling.
+
+        .. testcode::
+
+            import anki_vector
+
+            with anki_vector.Robot() as robot:
+                if robot.status.is_robot_moving:
+                    print("Vector has is in motion.")
+        """
+        return (self.__get() & ROBOT_STATUS_IS_ROBOT_MOVING) != 0

anki_vector/touch.py

@@ -0,0 +1,119 @@
+# Copyright (c) 2018 Anki, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License in the file LICENSE.txt or at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Support for Vector's touch sensor.
+
+The robot will forward a raw sensor reading representing the capacitance detected
+on its back sensor.  Accompanied with this value is a true/false flag that takes into
+account other aspects of the robot's state to evaluate whether the robot thinks it is
+being touched or not.  This flag is the same value used internally for petting detection.
+"""
+
+# __all__ should order by constants, event classes, other classes, functions.
+__all__ = ["TouchComponent", "TouchSensorData"]
+
+from . import util
+from .events import Events
+from .messaging import protocol
+
+
+class TouchSensorData:
+    """A touch sample from the capacitive touch sensor, accompanied with the robot's
+    conclusion on whether this is considered a valid touch.
+    """
+
+    def __init__(self, proto_data: protocol.TouchData):
+        self._raw_touch_value = proto_data.raw_touch_value
+        self._is_being_touched = proto_data.is_being_touched
+
+    @property
+    def raw_touch_value(self) -> int:
+        """The detected sensitivity from the touch sensor.
+
+        This will not map to a constant raw value, as it may be impacted by various
+        environmental factors such as whether the robot is on its charger, being held, humidity, etc.
+
+        .. testcode::
+
+            import anki_vector
+
+            with anki_vector.Robot() as robot:
+                touch_data = robot.touch.last_sensor_reading
+                if touch_data is not None:
+                    raw_touch_value = touch_data.raw_touch_value
+        """
+        return self._raw_touch_value
+
+    @property
+    def is_being_touched(self) -> bool:
+        """The robot's conclusion on whether the current value is considered
+        a valid touch.
+
+        .. testcode::
+
+            import anki_vector
+
+            with anki_vector.Robot() as robot:
+                touch_data = robot.touch.last_sensor_reading
+                if touch_data is not None:
+                    is_being_touched = touch_data.is_being_touched
+        """
+        return self._is_being_touched
+
+
+class TouchComponent(util.Component):
+    """Maintains the most recent touch sensor data
+
+    This will be updated with every broadcast RobotState, and can be queried at any time.
+
+    .. testcode::
+
+        import anki_vector
+
+        with anki_vector.Robot() as robot:
+            touch_data = robot.touch.last_sensor_reading
+            if touch_data is not None:
+                print('Touch sensor value: {0}, is being touched: {1}'.format(touch_data.raw_touch_value, touch_data.is_being_touched))
+    """
+
+    def __init__(self, robot):
+        super().__init__(robot)
+        self._last_sensor_reading = None
+
+        # Subscribe to a callback that updates the robot's local properties - which includes touch data.
+        self._robot.events.subscribe(self._on_robot_state,
+                                     Events.robot_state,
+                                     _on_connection_thread=True)
+
+    def close(self):
+        """Closing the touch component will unsubscribe from robot state updates."""
+        self._robot.events.unsubscribe(self._on_robot_state,
+                                       Events.robot_state)
+
+    @property
+    def last_sensor_reading(self) -> TouchSensorData:
+        """:class:`anki_vector.touch.TouchSensorData`: The last reported sensor data.
+
+        .. testcode::
+
+            import anki_vector
+
+            with anki_vector.Robot() as robot:
+                touch_data = robot.touch.last_sensor_reading
+        """
+        return self._last_sensor_reading
+
+    def _on_robot_state(self, _robot, _event_type, msg):
+        self._last_sensor_reading = TouchSensorData(msg.touch_data)