hackerbot 0.2.0__py3-none-any.whl

hackerbot/__init__.py

@@ -0,0 +1,33 @@
+################################################################################
+# Copyright (c) 2025 Hackerbot Industries LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+# Created By: Allen Chien
+# Created:    April 2025
+# Updated:    2025.04.08
+#
+# This is the file for the hackerbot package. It imports
+# and initialized the sub components
+#
+# Special thanks to the following for their code contributions to this codebase:
+# Allen Chien - https://github.com/AllenChienXXX
+################################################################################
+
+
+from .core import Core
+from .base import Base
+from .head import Head
+from .arm import Arm
+from .utils.hackerbot_helper import HackerbotHelper
+
+class Hackerbot(HackerbotHelper):
+    def __init__(self, port=None, board=None, model=None,verbose_mode=False):
+        super().__init__(port, board, verbose_mode)
+        # Share self (which is a HackerbotHelper) with subsystems
+        self.core = Core(controller=self)
+        self.base = Base(controller=self)
+        self.head = Head(controller=self)
+        self.arm = Arm(controller=self)
+        # TODO based on model decide which subsystems to initialize

hackerbot/arm/__init__.py

@@ -0,0 +1,77 @@
+################################################################################
+# Copyright (c) 2025 Hackerbot Industries LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+# Created By: Allen Chien
+# Created:    April 2025
+# Updated:    2025.04.07
+#
+# This module contains the Arm component of the hackerbot
+#
+# Special thanks to the following for their code contributions to this codebase:
+# Allen Chien - https://github.com/AllenChienXXX
+################################################################################
+
+
+from hackerbot.utils.hackerbot_helper import HackerbotHelper
+from .gripper import Gripper
+
+class Arm():
+    def __init__(self, controller: HackerbotHelper):
+        self._controller = controller
+        self.idle_mode = True
+
+        self.setup()
+        self.gripper = Gripper(self._controller)
+
+    def setup(self):
+       if not self._controller._arm_attached:
+            self._controller.log_warning("Arm not attached, can't control arm.")
+
+    def move_joint(self, joint_id, angle, speed):
+        """
+        Moves a single joint of the robotic arm to a specified angle at a given speed.
+
+        Args:
+            joint_id (int): Joint number from 1 to 6. Joint 1 is the base and is in order moving up the arm.
+            angle (float): Angle for the specified joint. Valid range is -165.0 to 165.0 degrees for joints 1 to 5 and -175.0 to 175.0 for joint 6.
+            speed (int): Speed at which the arm moves to the new position. Valid range is 0 to 100.
+
+        Returns:
+            bool: True if the movement command was successfully sent, False if an error occurred.
+        """
+        try:
+            self._controller.send_raw_command(f"A_ANGLE,{joint_id},{angle},{speed}")
+            # Not fetching json response since machine mode not implemented
+            return True
+        except Exception as e:
+            self._controller.log_error(f"Error in arm:move_joint: {e}")
+            return False
+    
+    def move_joints(self, j_agl_1, j_agl_2, j_agl_3, j_agl_4, j_agl_5, j_agl_6, speed):
+        """
+        Moves all six joints of the robotic arm to specified angles at a given speed.
+
+        Args:
+            j_agl_1 (float): Angle for joint 1, base joint. Valid range is -165.0 to 165.0 degrees.
+            j_agl_2 (float): Angle for joint 2. Valid range is -165.0 to 165.0 degrees.
+            j_agl_3 (float): Angle for joint 3. Valid range is -165.0 to 165.0 degrees.
+            j_agl_4 (float): Angle for joint 4. Valid range is -165.0 to 165.0 degrees.
+            j_agl_5 (float): Angle for joint 5. Valid range is -165.0 to 165.0 degrees.
+            j_agl_6 (float): Angle for joint 6. Valid range is -175.0 to 175.0 degrees.
+            speed (int): Speed at which the arm moves to the new positions. Valid range is 0 to 100.
+
+        Returns:
+            bool: True if the movement command was successfully sent, False if an error occurred.
+        """
+        try:
+            self._controller.send_raw_command(f"A_ANGLES,{j_agl_1},{j_agl_2},{j_agl_3},{j_agl_4},{j_agl_5},{j_agl_6},{speed}")
+            # Not fetching json response since machine mode not implemented
+            return True
+        except Exception as e:
+            self._controller.log_error(f"Error in arm:move_joints: {e}")
+            return False    
+            
+            

hackerbot/arm/gripper.py

@@ -0,0 +1,55 @@
+################################################################################
+# Copyright (c) 2025 Hackerbot Industries LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+# Created By: Allen Chien
+# Created:    April 2025
+# Updated:    2025.04.07
+#
+# This module contains the Gripper component of the hackerbot
+#
+# Special thanks to the following for their code contributions to this codebase:
+# Allen Chien - https://github.com/AllenChienXXX
+################################################################################
+
+
+from hackerbot.utils.hackerbot_helper import HackerbotHelper
+
+class Gripper(HackerbotHelper):
+    def __init__(self, controller: HackerbotHelper):
+        self._controller = controller
+
+    def calibrate(self):
+        """
+        Calibrates the gripper by sending a raw calibration command.
+
+        Returns:
+            bool: True if the calibration command was successfully sent, False if an error occurred.
+        """
+        try:
+            self._controller.send_raw_command("A_CAL")
+            # Not fetching json response since machine mode not implemented
+            return True
+        except Exception as e:
+            self._controller.log_error(f"Error in gripper:calibrate: {e}")
+            return False
+        
+    def open(self):
+        try:
+            self._controller.send_raw_command("A_OPEN")
+            # Not fetching json response since machine mode not implemented
+            return True
+        except Exception as e:
+            self._controller.log_error(f"Error in gripper:open: {e}")
+            return False
+            
+    def close(self):
+        try:
+            self._controller.send_raw_command("A_CLOSE")
+            # Not fetching json response since machine mode not implemented
+            return True
+        except Exception as e:
+            self._controller.log_error(f"Error in gripper:close: {e}")
+            return False

hackerbot/base/__init__.py

@@ -0,0 +1,223 @@
+################################################################################
+# Copyright (c) 2025 Hackerbot Industries LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+# Created By: Allen Chien
+# Created:    April 2025
+# Updated:    2025.04.08
+#
+# This module contains the Base component of the hackerbot
+#
+# Special thanks to the following for their code contributions to this codebase:
+# Allen Chien - https://github.com/AllenChienXXX
+################################################################################
+
+
+from hackerbot.utils.hackerbot_helper import HackerbotHelper
+from .maps import Maps
+import time
+
+class Base():    
+    def __init__(self, controller: HackerbotHelper):
+        """
+        Initialize Core component with HackerbotHelper object
+        
+        :param controller: HackerbotHelper object
+        """
+        self._controller = controller
+        self.initialize() # Call before any action is done on the base
+
+        self.maps = Maps(controller)
+
+        self._future_completed = False
+        self._docked = True # Default to true, assume always start from charger
+
+      
+    def initialize(self):
+        try:
+            self._controller.send_raw_command("B_INIT")
+            self._controller._base_init = True
+            # Not fetching json response since machine mode not implemented
+            return True
+        except Exception as e:
+            self._controller.log_error(f"Error in base:initialize: {e}")
+            raise Exception(f"Error in initialize: {e}")
+        
+    def set_mode(self, mode):
+        try:
+            self._controller.send_raw_command(f"B_MODE,{mode}")
+            # Not fetching json response since machine mode not implemented
+            return True
+        except Exception as e:
+            self._controller.log_error(f"Error in base:set_mode: {e}")
+            return False
+        
+    def status(self):
+        try:
+            self._controller.send_raw_command("B_STATUS")
+            time.sleep(0.1)
+            response = self._controller.get_json_from_command("status")
+            if response is None:
+                raise Exception("Status command failed")
+            
+            if response.get("left_set_speed") == 0 and response.get("right_set_speed") == 0:
+                self._future_completed = True
+            else:
+                self._future_completed = False
+
+                        # Parse and return relevant fields
+            parsed_data = {
+                "timestamp": response.get("timestamp"),
+                "left_encoder": response.get("left_encoder"),
+                "right_encoder": response.get("right_encoder"),
+                "left_speed": response.get("left_speed"),
+                "right_speed": response.get("right_speed"),
+                "left_set_speed": response.get("left_set_speed"),
+                "right_set_speed": response.get("right_set_speed"),
+                "wall_tof": response.get("wall_tof"),
+            }
+            return parsed_data
+        except Exception as e:
+            self._controller.log_error(f"Error in base:status: {e}")
+            return None
+        
+    def start(self, block=True):
+        try:
+            self._controller.send_raw_command("B_START")
+            # Not fetching json response since machine mode not implemented
+            self._controller._driver_mode = True
+            if self._docked:
+                time.sleep(2)
+                self._docked = False
+            self._wait_until_completed(block=block)
+
+            return True
+        except Exception as e:
+            self._controller.log_error(f"Error in base:start: {e}")
+            return False
+        
+    def quickmap(self, block=True):
+        """
+        Start the quick mapping process.
+
+        This function sends a command to the base to initiate the quick mapping process.
+        It first checks the system status to ensure all components are ready. If
+        the quick mapping command is successfully sent, the function returns True.
+        In case of any errors, it logs the error message and returns False.
+
+        :return: True if the quick mapping command is successful, False otherwise.
+        """
+        try:
+            self._controller.send_raw_command("B_QUICKMAP")
+            time.sleep(0.1)
+            # Not fetching json response since machine mode not implemented
+            self._wait_until_completed(block=block)
+            return True
+        except Exception as e:
+            self._controller.log_error(f"Error in base:quickmap: {e}")
+            return False
+        
+    def dock(self, block=True):
+        """
+        Dock the base to the docking station.
+
+        This function sends a command to the base to initiate the docking process.
+        It first checks the system status to ensure all components are ready. If
+        the docking command is successfully sent, the function returns True.
+        In case of any errors, it logs the error message and returns False.
+
+        :return: True if the docking command is successful, False otherwise.
+        """
+        try:
+            self._controller.send_raw_command("B_DOCK")
+            time.sleep(3)
+            # Not fetching json response since machine mode not implemented
+            self._wait_until_completed(block=block)
+            self._docked = True
+            self._controller._driver_mode = False
+            return True
+        except Exception as e:
+            self._controller.log_error(f"Error in base:dock: {e}")
+            return False
+
+
+    def kill(self):
+        """
+        Kill the base's movement. This is a blocking call and will not return until the base is stopped.
+        After calling this method, the base will not be able to move until start() is called again.
+        :return: True if successful, False otherwise.
+        """
+        try:
+            self._controller.send_raw_command("B_KILL")
+            self._controller._base_init = False
+            # Not fetching json response since machine mode not implemented
+            return True
+        except Exception as e:
+            self._controller.log_error(f"Error in base:kill: {e}")
+            return False
+        
+    def trigger_bump(self, left, right):
+        """
+        Trigger the bump sensors on the base.
+
+        :param left: 0 or 1 to disable or enable the left bump sensor.
+        :param right: 0 or 1 to disable or enable the right bump sensor.
+        :return: True if the command is successful, False if it fails.
+        """
+        left = 1 if True else 0
+        right = 1 if True else 0
+        try:
+            self._controller.send_raw_command("B_BUMP, {0}, {1}".format(left, right))
+            # Not fetching json response since machine mode not implemented
+            return True
+        except Exception as e:
+            self._controller.log_error(f"Error in base:trigger_bump: {e}")
+            return False
+        
+    def drive(self, l_vel, a_vel, block=True):
+        """
+        Set the base velocity.
+
+        :param l_vel: Linear velocity in mm/s. Positive is forward, negative is backward.
+        :param a_vel: Angular velocity in degrees/s. Positive is counterclockwise, negative is clockwise.
+        :return: True if the command is successful, False if it fails.
+        """
+        try:
+            if not self._controller._driver_mode:
+                self.start()
+            self._controller.send_raw_command(f"B_DRIVE,{l_vel},{a_vel}")
+            time.sleep(0.1)
+            response = self._controller.get_json_from_command("drive")
+            if response is None:
+                raise Exception("Drive command failed")
+            self._wait_until_completed(block=block)
+            return True
+        except Exception as e:
+            self._controller.log_error(f"Error in base:drive: {e}")
+            return False
+        
+    def _wait_until_completed(self, block=True):
+        if not block:
+            return
+        while not self._future_completed:
+            self.status()
+            # print(self.status())
+        self._future_completed = False
+        
+    def destroy(self, auto_dock=False):
+        """
+        Clean up and shut down the base.
+
+        This method kills the base's movement and optionally docks it before 
+        destroying the controller. If `auto_dock` is set to True, the base will 
+        dock before the destruction process.
+
+        :param auto_dock: If True, the base will dock before being destroyed. Defaults to False.
+        """
+        self.kill()
+        if auto_dock:
+            time.sleep(3.0)
+            self.dock(block=False)
+        self._controller.destroy()

hackerbot/base/maps.py

@@ -0,0 +1,147 @@
+################################################################################
+# Copyright (c) 2025 Hackerbot Industries LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+# Created By: Allen Chien
+# Created:    April 2025
+# Updated:    2025.04.07
+#
+# This module contains the Maps component of the hackerbot
+#
+# Special thanks to the following for their code contributions to this codebase:
+# Allen Chien - https://github.com/AllenChienXXX
+################################################################################
+
+
+from hackerbot.utils.hackerbot_helper import HackerbotHelper
+import time
+
+class Maps():
+    def __init__(self, controller: HackerbotHelper):
+        self._controller = controller
+        self._goto_completed = False
+
+        self.map_id = None
+        self._x = None
+        self._y = None
+        self._angle = None
+
+        self._goal_x = None
+        self._goal_y = None
+        self._goal_angle = None
+
+        self._docked = True
+
+    # Returns a string of map data
+    def fetch(self, map_id):
+        """
+        Fetch the map data for a given map id.
+
+        This function sends a command to the base to generate the map data
+        for a given map id. It first checks the system status to ensure all
+        components are ready. If the command is successfully sent, the
+        function returns the compressed map data as a string. In case of any
+        errors, it logs the error message and returns None.
+
+        :param map_id: The id of the map to fetch
+        :return: The compressed map data as a string if successful, None otherwise.
+        """
+        try:
+            # Check if controller and driver are initialized and in machine mode
+            command = f"B_MAPDATA,{map_id}"
+            self._controller.send_raw_command(command)
+            time.sleep(5)  # Wait for map to be generated
+            map_data_json = self._controller.get_json_from_command("mapdata")
+            if map_data_json is None:
+                raise Exception("No map {map_id} found")
+            return map_data_json.get("compressedmapdata")
+        except Exception as e:
+            self._controller.log_error(f"Error in maps:fetch: {e}")
+            return None
+    
+    # Returns a list of map ids
+    def list(self):
+        """
+        Get a list of available maps.
+
+        This function sends a command to the base to generate a list of available maps.
+        It first checks the system status to ensure all components are ready. If
+        the command is successfully sent, the function returns a list of map ids.
+        In case of any errors, it logs the error message and returns None.
+
+        :return: A list of map ids if successful, None otherwise.
+        """
+        try:
+            # Check if controller and driver are initialized and in machine mode
+            self._controller.send_raw_command("B_MAPLIST")
+            time.sleep(2)  # Wait for map list to be generated
+            map_list_json = self._controller.get_json_from_command("maplist")
+            if map_list_json is None:
+                raise Exception("No maps found")
+            return map_list_json.get("map_ids")
+        except Exception as e:
+            self._controller.log_error(f"Error in maps:list: {e}")
+            return None
+        
+    def goto(self, x, y, angle, speed, block=True):
+        """
+        Move the robot to the specified location on the map.
+
+        Args:
+            x (float): The x coordinate of the location to move to, in meters.
+            y (float): The y coordinate of the location to move to, in meters.
+            angle (float): The angle of the location to move to, in degrees.
+            speed (float): The speed at which to move to the location, in meters per second.
+
+        Returns:
+            bool: True if the command was successfully sent, False if an error occurred.
+        """
+        try:
+            command = f"B_GOTO,{x},{y},{angle},{speed}"
+            self._controller.send_raw_command(command)
+            self._goal_x = x
+            self._goal_y = y
+            self._goal_angle = angle
+            # Not fetching json response since machine mode not implemented
+            if self._docked == True:
+                time.sleep(2) # Some time to leave the base
+                self._docked = False
+            if block:
+                self._wait_until_reach_pose()
+            return True
+        except Exception as e:
+            self._controller.log_error(f"Error in maps:goto: {e}")
+            return False
+        
+    def position(self):
+        try:
+            self._controller.send_raw_command("B_POSE")
+            time.sleep(0.1)
+            pose = self._controller.get_json_from_command("pose")
+            if pose is None:
+                raise Exception("No position found")
+            self.map_id = pose.get("map_id")
+            self._x = pose.get("pose_x")
+            self._y = pose.get("pose_y")
+            self._angle = pose.get("pose_angle")
+            # Not fetching json response since machine mode not implemented
+            return {"x": self._x, "y": self._y, "angle": self._angle}
+        except Exception as e:
+            self._controller.log_error(f"Error in base:position: {e}")
+            return False
+        
+    def _wait_until_reach_pose(self):
+        while not self._goto_completed:
+            self.position()
+            self._calculate_position_offset()
+        self._goto_completed = False
+
+    def _calculate_position_offset(self):
+        x_offset = self._goal_x - self._x
+        y_offset = self._goal_y - self._y
+        angle_offset = (self._goal_angle - self._angle) // 180
+        # print("x_offset: {0}, y_offset: {1}, angle_offset: {2}".format(x_offset, y_offset, angle_offset))
+        if max(abs(x_offset), abs(y_offset), abs(angle_offset)) < 0.1:
+            self._goto_completed = True

hackerbot/core.py

@@ -0,0 +1,120 @@
+################################################################################
+# Copyright (c) 2025 Hackerbot Industries LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+# Created By: Allen Chien
+# Created:    April 2025
+# Updated:    2025.04.07
+#
+# This module contains the Core component of the hackerbot
+#
+# Special thanks to the following for their code contributions to this codebase:
+# Allen Chien - https://github.com/AllenChienXXX
+################################################################################
+
+
+from hackerbot.utils.hackerbot_helper import HackerbotHelper
+import time
+import json
+
+class Core():    
+    def __init__(self, controller: HackerbotHelper):
+        """
+        Initialize Core component with HackerbotHelper object
+        
+        :param controller: HackerbotHelper object
+        """
+        self.tofs_enabled = controller._tofs_enabled
+        self.json_response = controller._json_mode
+
+        self._controller = controller
+
+        self.ping() # Ping to check attached components
+
+    def ping(self):
+        """
+        Pings the main controller to check component statuses and returns a JSON-style string
+        indicating the status of the components.
+        This is called during set up.
+
+        :return: JSON-style string of component statuses or None if there is an error
+        """
+        try:
+            self._controller.check_controller_init()
+            self._controller.send_raw_command("PING")
+            time.sleep(0.1)
+            response = self._controller.get_json_from_command("ping")
+            if response is None:
+                raise Exception("No response from main controller")
+
+            # Build JSON-style dict for robot state (excluding warnings)
+            robots_state = {
+                "main_controller_attached": False,
+                "temperature_sensor_attached": False,
+                "audio_mouth_eyes_attached": False,
+                "dynamixel_controller_attached": False,
+                "arm_control_attached": False
+            }
+
+            # Check component statuses
+            self._controller._main_controller_attached = response.get("main_controller") == "attached"
+            self._controller._temperature_sensor_attached = response.get("temperature_sensor") == "attached"
+            self._controller._left_tof_attached = response.get("left_tof") == "attached"
+            self._controller._right_tof_attached = response.get("right_tof") == "attached"
+            self._controller._audio_mouth_eyes_attached = response.get("audio_mouth_eyes") == "attached"
+            self._controller._dynamixel_controller_attached = response.get("dynamixel_controller") == "attached"
+            self._controller._arm_attached = response.get("arm_controller") == "attached"
+
+            if not self._controller._main_controller_attached:
+                self._controller.log_warning("Main controller not attached")
+            if not self._controller._temperature_sensor_attached:
+                self._controller.log_warning("Temperature sensor not attached")
+            if not self._controller._left_tof_attached:
+                self._controller.log_warning("Left TOF not attached")
+            if not self._controller._right_tof_attached:
+                self._controller.log_warning("Right TOF not attached")
+
+            # Update status
+            robots_state["main_controller_attached"] = self._controller._main_controller_attached
+            robots_state["temperature_sensor_attached"] = self._controller._temperature_sensor_attached
+            robots_state["left_tof_attached"] = self._controller._left_tof_attached
+            robots_state["right_tof_attached"] = self._controller._right_tof_attached
+            robots_state["audio_mouth_eyes_attached"] = self._controller._audio_mouth_eyes_attached
+            robots_state["dynamixel_controller_attached"] = self._controller._dynamixel_controller_attached
+            robots_state["arm_control_attached"] = self._controller._arm_attached
+            # Convert to JSON string (excluding warnings) before returning
+            return json.dumps(robots_state, indent=2)
+
+        except Exception as e:
+            self._controller.log_error(f"Error in core:ping: {e}")
+            return None
+
+    def version(self):
+        """
+        Get the version numbers of the main controller, audio mouth eyes, dynamixel controller, and arm controller.
+
+        :return: A JSON string containing the version numbers of the components.
+        """
+        try:
+            self._controller.check_controller_init()
+            self._controller.send_raw_command("VERSION")
+            time.sleep(0.1)
+            response = self._controller.get_json_from_command("version")
+            if response is None:
+                raise Exception("No response from main controller")
+
+            # Build response dictionary with all relevant version info
+            version_info = {
+                "main_controller_version": response.get("main_controller"),
+                "audio_mouth_eyes_version": response.get("audio_mouth_eyes"),
+                "dynamixel_controller_version": response.get("dynamixel_controller"),
+                "arm_controller_version": response.get("arm_controller")
+            }
+
+            return json.dumps(version_info, indent=2)
+
+        except Exception as e:
+            self._controller.log_error(f"Error in core:versions: {e}")
+            return None