hackerbot 0.2.0__py3-none-any.whl

hackerbot/examples/keyboard_teleop_examples/base_teleop.py

@@ -0,0 +1,206 @@
+################################################################################
+# 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.01
+#
+# This script is an example of how to use the base teleop behavior.
+#
+# Special thanks to the following for their code contributions to this codebase:
+# Allen Chien - https://github.com/AllenChienXXX
+################################################################################
+
+
+from hackerbot import Hackerbot
+import time
+import os
+
+import sys, termios, atexit
+from select import select
+
+class KBHit:
+  
+  def __init__(self):
+    '''Creates a KBHit object that you can call to do various keyboard things.
+    '''
+    # Save the terminal settings
+    self.fd = sys.stdin.fileno()
+    self.new_term = termios.tcgetattr(self.fd)
+    self.old_term = termios.tcgetattr(self.fd)
+
+    # New terminal setting unbuffered
+    self.new_term[3] = (self.new_term[3] & ~termios.ICANON & ~termios.ECHO)
+    termios.tcsetattr(self.fd, termios.TCSAFLUSH, self.new_term)
+
+    # Support normal-terminal reset at exit
+    atexit.register(self.set_normal_term)
+
+
+  def set_normal_term(self):
+    ''' Resets to normal terminal.  On Windows this is a no-op.
+    '''
+    termios.tcsetattr(self.fd, termios.TCSAFLUSH, self.old_term)
+
+
+  def getch(self):
+    ''' Returns a keyboard character after kbhit() has been called.
+    '''
+    ch1 = sys.stdin.read(1)
+    if ch1 == '\x1b':
+      # special key pressed
+      ch2 = sys.stdin.read(1)
+      ch3 = sys.stdin.read(1)
+      ch = ch1 + ch2 + ch3
+    else:
+      # not a special key
+      ch = ch1
+    while sys.stdin in select([sys.stdin], [], [], 0)[0]:  
+        sys.stdin.read(1)
+    return ch
+
+
+  def kbhit(self):
+    ''' Returns True if keyboard character was hit, False otherwise.
+    '''
+    dr,dw,de = select([sys.stdin], [], [], 0)
+    while sys.stdin in select([sys.stdin], [], [], 0)[0]:  
+        sys.stdin.read(1)
+    return dr != []
+
+class BaseTeleop:
+    def __init__(self):
+        self.kb = KBHit()
+
+        self.robot = Hackerbot()
+        self.robot.base.initialize()
+        
+        # Modify movement parameters
+        self.step_size = 0.2 # mm
+        self.max_l_step_size = 300.0 # mm/s
+        self.max_r_step_size = 90.0 # degree/s
+
+        self.stop = False
+        self.last_key = None  # Track last keypress
+        
+        # Print initial instructions to terminal
+        self.print_terminal_instructions()
+
+    def print_terminal_instructions(self):
+        """Print instructions to the terminal"""
+        os.system('clear' if os.name == 'posix' else 'cls')
+        print("\n" + "="*10 + " Robot Teleop Controls " + "="*10 + "\r")
+        print("\nMoving controls:\r")
+        print("   ↑ / ↓    : forward/backward |   ← / →    : rotate left/right | space  : stop\r")
+        print("o/p : increase/decrease step size by 10%\r")
+        print("\nCTRL-C or '0' to quit\r")
+        print("=" * 43 + "\r")
+
+    def update_display(self):
+        """Update step size in place without adding new lines"""
+        sys.stdout.write(f"\rCurrent step size: {self.step_size:.2f}m\r")
+        sys.stdout.flush()  # Ensure immediate update
+
+    def get_command(self):
+        key = None
+        # Read keyboard input
+        if self.kb.kbhit() is not None:
+            key = self.kb.getch()
+            while sys.stdin in select([sys.stdin], [], [], 0)[0]:  
+                sys.stdin.read(1)
+
+            if key == self.last_key:
+                self.last_key = None
+                return None, None  
+
+            self.last_key = key  # Update last key
+
+            # Check for quit conditions
+            if key == '0':  # '0' key to quit
+                self.stop = True
+                return None, None
+                
+            if key == 'o':
+                self.step_size += 0.1
+            elif key == 'p':
+                self.step_size -= 0.1
+            if key in ['\x1b[A', '\x1b[B', '\x1b[D', '\x1b[C', ' ']:
+                l_vel, r_vel = self.get_base_command_from_key(key)
+            else:
+                l_vel = None
+                r_vel = None
+                
+            return l_vel, r_vel
+        else:
+            self.last_key = None
+            return 0.0, 0.0
+
+    def get_base_command_from_key(self, key):
+        if key == '\x1b[A':  # Up arrow - Forward
+            l_vel = self.max_l_step_size * self.step_size
+            r_vel = 0.0
+        elif key == '\x1b[B':  # Down arrow - Backward
+            l_vel = -self.max_l_step_size * self.step_size
+            r_vel = 0.0
+        elif key == '\x1b[D':  # Left arrow - Rotate left
+            l_vel = 0.0
+            r_vel = self.max_r_step_size * self.step_size
+        elif key == '\x1b[C':  # Right arrow - Rotate right
+            l_vel = 0.0
+            r_vel = -self.max_r_step_size * self.step_size
+        elif key == ' ':  # Space - Stop
+            l_vel = 0.0
+            r_vel = 0.0
+        else:
+            l_vel = None
+            r_vel = None
+        return l_vel, r_vel
+
+    def run(self):
+        while not self.stop:
+            l_vel, r_vel = self.get_command()
+            if l_vel is not None and r_vel is not None:
+                respone = self.robot.base.drive(l_vel, r_vel, block=False)
+                if respone == False:
+                    break
+            l_vel = None
+            r_vel = None
+            # time.sleep(0.01)
+            self.update_display()
+    def cleanup(self):
+        """Cleanup method to properly shut down the robot and restore terminal settings"""
+        try:
+            # Restore terminal settings
+            self.kb.set_normal_term()
+            # Destroy the robot connection
+            self.robot.base.destroy(auto_dock=True)
+            
+        except Exception as e:
+            print(f"\nError during cleanup: {e}")
+            # Try to restore terminal settings even if there's an error
+            try:
+                self.kb.set_normal_term()
+            except:
+                pass
+
+    def __del__(self):
+        """Destructor to ensure cleanup is called"""
+        self.cleanup()
+
+
+# Main entry point
+if __name__ == '__main__':
+    teleop = None
+    try:
+        teleop = BaseTeleop()
+        teleop.run()
+    except KeyboardInterrupt:
+        print("\nShutting down...")
+    except Exception as e:
+        print(f"\nError: {e}")
+    finally:
+        if teleop:
+            teleop.cleanup()

hackerbot/examples/keyboard_teleop_examples/head_teleop.py

@@ -0,0 +1,170 @@
+################################################################################
+# 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.01
+#
+# This script is an example of how to use the head teleop behavior.
+#
+# Special thanks to the following for their code contributions to this codebase:
+# Allen Chien - https://github.com/AllenChienXXX
+################################################################################
+
+
+from hackerbot import Hackerbot
+import time
+import os
+
+import sys
+from select import select
+from base_teleop import KBHit
+
+class HeadTeleop:
+    def __init__(self):
+        self.kb = KBHit()
+
+        self.robot = Hackerbot()
+        self.robot.head.set_idle_mode(False)
+        
+        # Modify movement parameters
+        self.joint_speed = 50
+        self.step_size = 0.2 # mm
+
+        self.yaw = 180
+        self.pitch = 180
+
+        self.stop = False
+        self.last_key = None  # Track last keypress
+        
+        # Print initial instructions to terminal
+        self.print_terminal_instructions()
+
+    def print_terminal_instructions(self):
+        """Print static instructions to the terminal"""
+        os.system('clear' if os.name == 'posix' else 'cls')
+        print("\n" + "="*10 + " Robot Head Teleop Controls " + "="*10 + "\r")
+        print("   u/i : Yaw rotate L/R")
+        print("   j/k : Pitch rotate B/F")
+        
+        print("\nOther Controls:")
+        print("   p/o : increase/decrease step size")
+        print("   -/+ : decrease/increase speed")
+        print("\nCTRL-C or 0 to quit")
+        
+        # Reserve space for dynamic updates
+        print("\n" + "=" * 43 + "\r")
+
+    def update_display(self):
+        """Update step size and speed in place without adding new lines"""
+        sys.stdout.write(f"\rCurrent step size: {self.step_size:.1f}   |   Current speed: {self.joint_speed}%    ")
+        sys.stdout.flush()  # Ensure immediate update
+
+
+    def get_head_command(self):
+        key = None
+        # Read keyboard input
+        if self.kb.kbhit() is not None:
+            key = self.kb.getch()
+            
+            while sys.stdin in select([sys.stdin], [], [], 0)[0]:  
+                sys.stdin.read(1)
+
+            if key == self.last_key:
+                self.last_key = None
+                return None, None  
+
+            self.last_key = key
+
+            # Check for quit conditions
+            if key == '0':  # ESC or Ctrl-C
+                self.stop = True
+                return None, None
+            
+            if key == 'o':
+                self.step_size += 0.1
+            elif key == 'p':
+                self.step_size -= 0.1
+            if key == '-':
+                self.joint_speed -= 10
+                if self.joint_speed < 0:
+                    self.joint_speed = 0
+            elif key == '+':
+                self.joint_speed += 10
+                if self.joint_speed > 100:
+                    self.joint_speed = 100
+
+            return self.get_head_value_from_key(key)
+        else:
+            self.last_key = None
+            return None, None
+
+    def get_head_value_from_key(self, key):
+        # Joint controls
+        if key == 'u':    # Joint 1 left
+            self.yaw += self.step_size*100
+            self.yaw = max(100, min(260, self.yaw))
+        elif key == 'i':  # Joint 1 right
+            self.yaw -= self.step_size*100
+            self.yaw = max(100, min(260, self.yaw))
+        elif key == 'j':  # Joint 2 left
+            self.pitch += self.step_size*100
+            self.pitch = max(150, min(250, self.pitch))
+        elif key == 'k':  # Joint 2 right
+            self.pitch -= self.step_size*100
+            self.pitch = max(150, min(250, self.pitch))
+        else:
+            return None, None
+        
+        return self.yaw, self.pitch
+
+    def run(self):
+        while not self.stop:
+            y, p = self.get_head_command()
+            if y is not None and p is not None:
+                response = self.robot.head.look(y, p, self.joint_speed)
+
+            time.sleep(0.2)
+            if response == False:
+                break
+            self.update_display()
+
+    def cleanup(self):
+        """Cleanup method to properly shut down the robot and restore terminal settings"""
+        try:
+            # Restore terminal settings
+            self.kb.set_normal_term()
+            # Dock the robot
+            self.robot.head.look(180,180,50) 
+            # Destroy the robot connection
+            self.robot.destroy()
+            
+        except Exception as e:
+            print(f"\nError during cleanup: {e}")
+            # Try to restore terminal settings even if there's an error
+            try:
+                self.kb.set_normal_term()
+            except:
+                pass
+
+    def __del__(self):
+        """Destructor to ensure cleanup is called"""
+        self.cleanup()
+
+
+# Main entry point
+if __name__ == '__main__':
+    teleop = None
+    try:
+        teleop = HeadTeleop()
+        teleop.run()
+    except KeyboardInterrupt:
+        print("\nShutting down...")
+    except Exception as e:
+        print(f"\nError: {e}")
+    finally:
+        if teleop:
+            teleop.cleanup()

hackerbot/head/__init__.py

@@ -0,0 +1,61 @@
+################################################################################
+# 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 Head 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 .eyes import Eyes
+
+class Head():
+    def __init__(self, controller: HackerbotHelper):
+        self._controller = controller
+        self.idle_mode = True
+
+        self.setup()
+        self.eyes = Eyes(self._controller)
+
+    def setup(self):
+        if not self._controller._dynamixel_controller_attached:
+            self._controller.log_warning("Dynamixel controller not attached, can't control head.")
+        if not self._controller._audio_mouth_eyes_attached:
+            self._controller.log_warning("Audio mouth and eyes not attached, can't control eyes.")
+
+        self.set_idle_mode(True)
+        
+    # float: yaw - Unit is in degrees (eg. 180 degrees). Valid values are in the range of 100.0 to 260.0
+    # float: pitch - Unit is in degrees (eg. 180 degrees). Valid values are in the range of 150.0 to 250.0
+    # int: speed - Unitless. Valid values are integers in the range of 6 (slow) to 70 (fast)
+    def look(self, yaw, pitch, speed):
+        try:
+            self.set_idle_mode(False)
+            self._controller.send_raw_command(f"H_LOOK, {yaw}, {pitch}, {speed}")
+            # Not fetching json response since machine mode not implemented
+            return True
+        except Exception as e:
+            self._controller.log_error(f"Error in head:look: {e}")
+            return False
+        
+    def set_idle_mode(self, mode):
+        try:
+            if mode:
+                self._controller.send_raw_command("H_IDLE, 1")
+            else:
+                self._controller.send_raw_command("H_IDLE, 0")
+            # Not fetching json response since machine mode not implemented
+            self.idle_mode = mode
+            return True
+        except Exception as e:
+            self._controller.log_error(f"Error in head:set_idle_mode: {e}")
+            return False

hackerbot/head/eyes.py

@@ -0,0 +1,41 @@
+################################################################################
+# 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 Eyes 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 Eyes():
+    def __init__(self, controller: HackerbotHelper):
+        self._controller = controller
+
+    def gaze(self, x, y):
+        """
+        Move the eyes to the specified position in the view.
+
+        Args:
+        x (float): x position between -1.0 and 1.0
+        y (float): y position between -1.0 and 1.0
+
+        Returns:
+        bool: Whether the command was successful
+        """
+        try:
+            self._controller.send_raw_command(f"H_GAZE,{x},{y}")
+            # Not fetching json response since machine mode not implemented
+            return True
+        except Exception as e:
+            self._controller.log_error(f"Error in eyes:gaze: {e}")
+            return False

hackerbot/utils/hackerbot_helper.py

@@ -0,0 +1,142 @@
+################################################################################
+# 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 HackerbotHelper class, which is a subclass of SerialHelper.
+# It contains the fields that will be share among higher level classes.
+#
+# Special thanks to the following for their code contributions to this codebase:
+# Allen Chien - https://github.com/AllenChienXXX
+################################################################################
+
+
+from .serial_helper import SerialHelper
+import time
+import logging
+
+class HackerbotHelper(SerialHelper):
+    def __init__(self, port=None, board=None, verbose_mode=False):
+        self._error_msg = ""
+        self._warning_msg = ""
+        self._v_mode = verbose_mode
+        self._main_controller_init = False  # Ensure this is set before exception handling
+
+        self._json_mode = False
+
+        self._main_controller_attached = False
+        self._temperature_sensor_attached = False
+
+        self._left_tof_attached = False
+        self._right_tof_attached = False
+
+        self._tofs_enabled = False
+        
+        self._base_init = False
+        self._driver_mode = False
+        
+        self._audio_mouth_eyes_attached = False
+        self._dynamixel_controller_attached = False
+
+        self._arm_attached = False
+        
+        self._port = port
+        self._board = board
+
+        self.setup()
+
+
+    def setup(self):
+        """
+        Initialize the main controller.
+
+        If self._port and self._board are None, this method will find the first available serial port and use it to initialize the main controller.
+        Otherwise, it will use the provided port and board to initialize.
+        After initialization, it will set the main controller to JSON mode and enable the TOFs.
+        This setup ensures json mode are set and controller is initialized properly.
+        If an exception occurs during initialization, it will raise an exception with the error message.
+        """
+        try:
+            if self._port is None or self._board is None:
+                super().__init__()
+                self._board, self._port = super().get_board_and_port()
+            else:
+                super().__init__(self._port, self._board)
+
+            self._main_controller_init = True
+            self.set_json_mode(True)
+            # self.set_TOFs(True)
+        except Exception as e:
+            raise Exception(f"Error in setting up hackerbot helper: {e}")
+
+    # Activate JSON mode
+    def set_json_mode(self, mode):
+        try:
+            if mode == True:
+                super().send_raw_command("JSON, 1")
+                time.sleep(0.1) # Short sleep to process json response
+                response = super().get_json_from_command("json")
+                if response is None:
+                    raise Exception("Failed to set json mode to: ", mode)
+            else:
+                super().send_raw_command("JSON, 0")
+            self._json_mode = mode
+        except Exception as e:
+            raise Exception(f"Error in set_json_mode: {e}")
+
+    #Set TOFs
+    def set_TOFs(self, mode):
+        try:
+            if not self._left_tof_attached or not self._right_tof_attached:
+                raise Exception("TOFs not attached")
+            if mode == True:
+                super().send_raw_command("TOFS, 1")
+            else:
+                super().send_raw_command("TOFS, 0")
+            time.sleep(0.1) # Short sleep to process json response
+            response = super().get_json_from_command("tofs")
+            if response is None:
+                raise Exception("TOFs activation failed")
+            self._tofs_enabled = mode
+        except Exception as e:
+            raise Exception(f"Error in set_TOFs: {e}")
+
+    def get_current_action(self):
+        return super().get_state()
+    
+    def get_error(self):
+        # Serial error should be priority
+        if super().get_ser_error() is not None:
+            return super().get_ser_error()
+        else:
+            return self._error_msg
+
+    def log_error(self, error):
+        if self._v_mode:
+            logging.error(error)
+        self._error_msg = error
+
+    def log_warning(self, warning):
+        if self._v_mode:
+            logging.warning(warning)
+        self._warning_msg = warning
+
+    def check_controller_init(self):
+        if not self._main_controller_init:
+            raise Exception("Main controller not initialized.")
+        if not self._json_mode:
+            raise Exception("JSON mode not enabled.")
+
+    def destroy(self):
+        try:
+            super().disconnect_serial()
+            self._main_controller_init = False
+            return True
+        except Exception as e:
+            self.log_error(f"Error in destroy: {e}")
+            return False