Software for the control and management of the Stanford Pupper Robot
This readme is behind. Please find more complete documentation here
- in order to install pybluez you may first need to install libbluetooth-dev
sudo apt-get install libbluetooth-dev
- for PyQt you need (Only for keyboard interface, not needed on pupper):
- sudo apt-get install python3-pyqt5 pyqt5-dev-tools qttools5-dev-tools
The simplest way to setup the robot is to clone this github repo onto a USB and copy it onto a raspberry pi 4 running a fresh install of Raspbian Buster. I recommend creating a code folder in the home folder and then housing all of the required code in there. For our build this folder was named pupper_code.
At first, you can simply open the file PupperPy/pupperpy/setup_script.sh directly from the usb and following along. DO NOT run the setup_script, it is not designed to be run. Instead treat it as a bunch of runnable code segements and guiding comments to allow a few different setup configurations. Just copy-pasta what you need into a terminal one line or block at a time.
Though the below methods can still be used, a simpler but less versatile usage is to pip install the pupperpy package:
cd /your/path/to/PupperPy
sudo pip3 install -e pupperpyand now you can startup all processes with one command:
sudo python3 /your/path/to/PupperPy/pupperpy/run_cerbaris.pyand then connecting your PS4 controller. Now cerbaris is ready to run. Just hit the L1 button to activate. L2 can be used to emergency stop the pupper, with L1 being able to re-activate.
The automated control system is located in the pupperpy/CommandInterface.py file. Currently control of the pupper is done using the CommandInterface.Control object and the cerbaris_robot service, which simply runs StandfordQuadrupped/run_robot.py.
When instantiated the Control object connects to a PS4 controller (for activation and emergency stop). Also this creates instances of the objects monitoring sensor data as well as UDPComms Subscribers & Publishers for getting data from the pupper_vision.py script (can be run via the pupper_vision service or called directly in terminal).
In Terminal,
cd /your/path/to/PupperPy
sudo ipythonIn IPython,
from pupperpy.CommandInterface import Control
control = Control()When prompted connect the PS4 controller by holding the power and "share"
buttons simultaneously until you see a double-blinking white light. When the
light turns green then the controller is connected to the robot.
The control loop functions by maintaining a ControllerState object and sending it to the run_robot script ~every 50ms. This is important since the PositionTracker has a pointer to this same object since it needs to know the current command state to update the Kalman filter. This means that if you ever re-instantiate the ControllerState object during your behaviors then the PositionTracker will be unable to know what commands are controlling the robot.
After instantiating the Control object and connecting the PS4 controller, the cerbaris_robot and pupper_vision services can be started (starting these before Control object creation may cause them to error).
In another Terminal,
sudo python3 /your/path/to/PupperPy/pupperpy/Vision/pupper_vision.py &
sudo systemctl restart cerbaris_robotThen the Control object can be run.
In IPython,
control.run_loop()This will start a timer that calls the control._step() function approximately
every 50 ms. To activate the robot you can either press the L1 button on the
PS4 controller, or use the control.activate() command in IPython.
The _step() function uses the sensors data to determine the appropriate
behavioral state and then calls a function to properly manipulate the
ControllerState object.
To help with implementation of behaviors the Control object has some built in functions that can be used to build behaviors.
control.move_forward() # moves forward at max safe velocity
control.move_backward() # moves backward at max safe velocity
control.move_stop() # stops forward and backward movement
control.turn_left() # turns left
control.turn_right() # turns right
control.turn_stop() # stops turning
control.activate() # Activates robot, initializes motor positions
control.start_walk() # switches robot gait from REST to TROT
control.stop_walk() # switches robot gait from TROT to REST