Height of base reduced from 41.5 to 25 mm – distance from palm pad to bottom of hand is only 62 mm.
Weight reduced from 1.2 kg to 0.98 kg.
Power supply efficiency improved; no-load power draw reduced from 7.5 watts to 4.7 watts.

1.2 BH8-282 System Components {#1.2-bh8-282-system-components}

In the Box

BarrettHand Shipping Case
BarrettHand BH8-282 (B4756)
Threaded Aluminum Ring for base (B2211)
Universal Power Supply - 48V (B4062)
BarrettHand BH8-282 Maintenance Kit
- Acrylic finger angle fixture (B3729)
- Grease (Mobil 1) in syringe
- Small packet of Threadlock
- Tweezers
- Dental Tool
- Hex Wrench Kit
- 2mm Hex Driver, Wiha brand
- Phillips Head Screwdriver, Wiha brand, size PH1
- Flathead Screwdriver, Wiha brand, size 2
Torque Wrench (B3436)
Metal Stand (B3978 <– Same part #?)
Sheet metal Adapter Mount (B1402)
USB-to-CAN Converter (B5382)
USB-to-Serial Converter (B5397)
USB Flash Drive (B3977)
BarrettHand External Cable (B5442)
AC Power Cable
Serial Cable
Barrett Technology DVD
Business Envelope
Quick-start Sheet

Additional Information

The Hand

The BarrettHand™, shown in Figure 1, has three fingers labeled F1, F2 and F3. Two of the fingers, F1 & F2, rotate synchronously and symmetrically about the base joint. The “spread” motion around the palm allows “on-the-fly” grasp reconfiguration to adapt to varying target object sizes, shapes, and orientations.

Aside from the spread motion, each of the three fingers on the BarrettHand™ feature two joints driven by a single DC brushless servo motor. The joints of each finger are coupled through Barrett’s patented TorqueSwitch™, which automatically switches motor torque to the appropriate finger joint when closing on a target object. Using the fingers together allows the BarrettHand™ to “grasp” a wide variety of objects securely. The TorqueSwitch™ combined with the spread function, makes object grasping nearly target-independent.

The BarrettHand™, shown in Figure 1, is equipped with a threaded base for compact and secure mounting. The threaded base is fully compatible with the WAM Arm. And, with the arm adapter, it can be mounted on virtually any robot with a standard ISO tool plate, for easy installation and maintenance.

Figure 1: BarrettHand™

Power Supply

The BH8-28x power supply shown in Figure 2 is compact and designed to run a hand from a host computer over serial or CAN. The user should connect all wires which connect to the power supply before turning on power. A control switch sets RS-232 or CAN mode and accepts control input from the same DB9 connector. The unit is powered through an AC line cord and provides all the necessary power to the hand. Internally, an industrial grade power supply called the Synqor AcuQor provides a semi-regulated 48 V to power the hand.

CAUTION: Do not try to power previous hand models with this power supply because earlier models were limited to 24 V. Never provide RS-232 signals while in CAN mode because it can cause damage to the electronics.

Figure 2 - BarrettHand™ BH8-28x 48-Volt Universal Power Supply

Electrical Cables

All necessary electrical cables are included in the basic BH8-282 System. The required electrical connections are shown in Figure 2. An AC Line Cord connects the Power Supply to a wall source. A DB9 Extension Cable provides the communications connection from a host computer via RS-232 serial or CAN. A Hand Cable for the particular Power Supply and BarrettHand™ supply communications, logic power, and motor power. This cable is durable and flexible, allowing the BarrettHand™ to be used on any robot with minimal effect on robot performance. Use the included set of adhesive guide clips for cable management. Since the control electronics reside inside the BarrettHand™ itself, no other electrical cabling is required.

The typical connection to BH8-282 systems use a Peak USB to CAN adapter that connects to a DB-9 extension cable and the BH8-28x power supply, which is shown in Figure 3.

Figure 3: USB to CAN Adapter for BH8-282 BarrettHand™

Lab Bench Stand

The bench mount stand for the BarrettHand™, shown in Figure 4, is ideal for off-arm development. The durable Aluminum stand comes complete with cable management clips and mounting features to hold your BarrettHand™ unit securely on any flat surface. Non-slip rubber feet keep the stand from sliding during testing and programming. A threaded locking ring for base mounting will secure the hand to the stand.

Figure 4: Lab Bench Stand, multiple wiring options

Control Software and Firmware

The BH8-SERIES System control software consists of:

BarrettHand™ Control GUI application and API,
Firmware (latest *.tek file), and
Example and demo programs.

BarrettHand™ Control GUI

The BarrettHand™ Control GUI is a cross-platform compatible Windows/Linux application that allows control of the BarrettHand™ quickly and easily. The BarrettHand™ Control GUI can be used to demonstrate functionality, test Supervisory and RealTime control sequences, and how to save those sequences as ASCII text or even as cross-platform compatible C++ code along with a Makefile (literally with the click of a “Generate C++ Code” button). See the BarrettHand™ Control GUI Manual for more information on the using this application and the requirements.

C++ Function Library

The BarrettHand™ C++ Function Library is an API for programming the BarrettHand™ using the C++ language on a Windows or Linux PC without having to manage various communication and timing issues. The library contains a hand control class that has easy-to-use functions that permit the use of Supervisory and RealTime commands in software developed by the user. All of the functions are available when the library and its dependencies are linked to the program. Dependencies are usually installed by default so the user can focus on development. The C++ API includes HTML generated documentation that describes all of the classes, variables, and methods that users should use in detail and gives examples.

The API is written in C++ and is compiled for Linux and Windows. The library provides a class from which you instantiate one BHand object and use it for all communications. The library uses a multithreaded mechanism for sending commands, which allows both synchronous and asynchronous access to the low-level thread and ensures that all communications are executed with high priority. The low-level thread manages all input and output buffers and makes controlling the BarrettHand™ easy.

Firmware

The BarrettHand™ has firmware that resides on the control electronics inside the palm. The firmware is a compiler generated text file that may be uploaded to the hand through the boot loader and the configuration tab in the GUI. The firmware receives commands, controls the motors, sets and retrieves properties, and reads or writes to the EEPROM.

System Options

Arm Adapter

Barrett Technology provides an arm adapter (Figure 5) matching the make and model of any robot specified by the customer. This lightweight arm adapter is made to work with the end-effector bolt pattern on your robot, allowing quick, easy mounting and wire management for a BH8-SERIES System. The arm adapter is bolted to the end of the robot arm and the BarrettHand™ is secured to the arm adapter with its standard threaded locking ring. The arm adapter is also equipped with an anti-rotation feature to prevent rotation during operation.

Figure 5: Arm Adapter

Fingertip Torque Sensing Option

Barrett Technology offers a set of three factory-installed torque sensors (one per finger) for the BarrettHand™ system. Each sensor measures the torque externally applied about the distal joint over a range of +/- 1 N-m. This option uses strain-gages to measure the differential tension in the “tendon” running through each finger to the second joint. The information is processed in additional on-board circuitry when this option is installed, it is accessed by requesting the present strain-gage parameter. The strain-gage parameter represents the amount of strain on the strain-gage sensors (values can be calibrated by the customer to relate strain to joint torque).

Tactile Sensing Option

The BarrettHand™ with Tactile-Sensing provides 24 cells of tactile-array data per finger plus 24 cells for the palm. Note that the Perception Palm option replaces the palm’s tactile array. The density of cells becomes higher towards the very tips of the fingers where finer spatial resolution is desirable. The entire Tactile-Sensing option is seamlessly integrated with the BarrettHand mechanically, electronically, and in the firmware and software. Furthermore, the calibration data is stored with each fingertip and the palm so that if you swap fingers, for example, the system is intelligent enough to maintain the correct calibrations.

1.3 BH8-282 Hardware setup

Initial Configuration

Initial electrical configuration of the newer BH8-282

NOTE: If using a BarrettHand equipped with a Force/Torque Sensor, BOTH jumpers in area C should be connected. This allows power to come through the side port of the BarrettHand and feed the Force/Torque Sensor through the bottom port.

Mounting Method 1: Lab Bench Stand - demonstrated with a BH8-282 model

The Aluminum Bench Stand you received with the BarrettHand™ has been provided for convenience in programming the BarrettHand™ when a host robot arm is not available. Use the wire guides to provide strain relief to the Hand cable. The steps laid out below illustrate how to mount the Hand in the stand.

Place the BarrettHand™ on the stand’s dowel pins. Note the alignment of the BarrettHand™ relative to the wire strain relief clips to ease connection of the BarrettHand™ Cable.
Screw on the threaded ring.
Plug the cable into your preferred configuration. IMPORTANT - make sure you have followed Step 2 of the initial configuration instructions (top of page) to let the hand know which port to draw power from, side or bottom.
- If attaching cable to underside of hand, use the 2-mm hex wrench to open fingers 1, 2, & 3 (see here¹). Spread fingers to roughly 120 degrees and rest the unit on its fingertips. Tighten screws to lock cable.
Zip Tie the BarrettHand™ Cable across the cable clip at an appropriate tension to provide strain relief.

Mounting Method 2: On Robot Arm

Robot-Arm Adapter

Like the Aluminum Bench Stand, the Robot Arm Adapter is made to secure the BarrettHand™ in place and to provide strain relief to the Hand cable. The Arm Adapter is fabricated for the tool-plate of your specific robot arm and is designed for low-profile, rigidity, and low weight.

To mount your BarrettHand™ on a robot, bolt the arm adapter onto the tool-plate bolt circle located at the end tip of the robot arm. Fit the BarrettHand™ onto the projecting pins on the Robot-Arm Adapter, and secure the BarrettHand™ by threading the locking ring (included with your system) onto the base of the BarrettHand™. Note that, depending on the details of your robot arm, you may need to loosen the locking ring when installing the Hand cable in the next Section.

Figure 12 - Installing an Arm Adapter.

Installing the Hand Cable on a Robot Arm

All of the power and communications for the BarrettHand™ have been consolidated into a single high-durability robot cable which has an 11-pin bayonet-style connector at the Power Supply end and a tiny 10-pin Hirose connector at the Hand end. To accommodate the complex motions of a robot arm, the BarrettHand™ Hand Cable is extremely flexible and has been designed for compatibility with both internal and external mounting schemes. When a robot arm does provide an internal channel, the cross-section of the channel is tightly constrained. Therefore the Hand cable has been made with a particularly tiny connector at one end to ease internal installation. The base of the Hand Adaptor includes an opening to accommodate direct access from an internal cable to the back of the BarrettHand™.

For external installation, plan to route the Hand Cable close to the center of each joint. Each segment will need enough slack to accommodate the most extreme motions but not so much that the cable might become snagged. Mount the cable clips to flat, dry, and clean link surfaces at strategic points along the robot arm. Clean cable clip attachment areas with alcohol before attaching via the self-adhesive backings. Place the BarrettHand™ Hand Cable loosely through the cable retaining clips on the robot and the Arm Adapter. Move the robot arm through all of its motion extremes to verify that the cable slack is adequate in each segment and that it will not snag. Once verified, tighten the cable clips to secure the cable in place.

Electrical Connections

Place the Power Supply on a flat, secure surface anywhere between the base of the robot and the host PC (or robot controller).
With your PC off, attach the DB-9 extension cable from your 9-pin COM Port or Peak USB to CAN adapter to the Power Supply. Barrett Technology supplies a 3-meter standard straight-through DB-9 cable, but you may purchase a longer cable if desired.
Attach the Power Supply Line Cord into any convenient outlet and verify that it is switched OFF. Attach one end of the Hand Cable to the Power Supply and the other end into the Hand. Tighten the strain-relief screws using the Phillips screwdriver provided in the toolkit.
Check the switches on the bottom of the hand under the access panel. For CAN operation, make sure the CAN termination is ON (SW1, #4), SW3 is set to CAN (the side with the dot), and J35/J36 is correct for which port you are using (jumper on J36 for bottom connector).

Power-Up Sequence

Once the previous steps are complete, your BH8-SERIES System is ready for use. Power up the system according to the instructions below:

Verify the DB-9 extension cable is plugged into the desired communications port (or Peak USB to CAN adapter) and into the 9-pin connector on the back of the Power Supply.
Verify the Hand Cable is plugged into the back of the Power Supply and into the bottom of the BarrettHand™.
Verify the AC line Line Cord cord is plugged into a valid power source and into the power outlet on the Power Supply.
Turn on the host computer.
Turn on the Power Supply. The main power switch is located on the back panel.
The BarrettHand™ is now ready for operation.

1.4 Software Setup

Host Computer

The BH8-SERIES control software was written for computers running Windows XP or Ubuntu 12.04. Barrett recommends using a processor with a clock speed of 1 GHz or greater, 1 GB of RAM, at least a gigabyte of free disk space, and a modern graphics card to run the BarrettHand Control GUI (a cross-platform wxWidgets-based application). Communications require one available USB port for the Peak USB to CAN adapter or the USB to RS-232 Serial adapter.

Installing BH8-SERIES Control Software

The BH8-SERIES Control Software consists of the BarrettHand Control GUI, firmware, example, and demo programs. The BarrettHand Control GUI is a graphical user interface that allows you to control the BarrettHand™ quickly and easily. The BarrettHand Control GUI can be used to test Supervisory and RealTime control sequences, determine communication loop rates, demonstrate functionality, help you learn how to independently write C++ code, and automatically generate C++ code based on tested algorithms. Run the bhand*.exe installer on Windows or install the bhand*.deb on Ubuntu to install the BarrettHand Control GUI, the most recent version of firmware, and example programs.

1.5 PyHand (Python) Setup for BarrettHand BH8-Series

PyHand is an easy to use GUI (graphical user interface) for interacting with and diagnosing BH8-280 and BH8-282 BarrettHands.

Installation Instructions

Uninstall any old versions of PyHand.
Download PyHand from here:
1. Windows: https://web.barrett.com/support/BarrettHand_Installer/Install_pyHand_2.1.exe
2. Linux: https://web.barrett.com/support/BarrettHand_Installer/Install_pyHand_2.0.tar.gz
Execute the installer, and follow the on-screen prompts to complete. Be sure to install the PEAK USB-CAN driver when prompted.
Manual for pyHand 2.0:
1. http://web.barrett.com/support/BarrettHand_Installer/pyHand_Manual_2.0.pdf

1.6 BHControl (C++) Software Setup - Windows

This file describes how to build the BarrettHand Control GUI, BarrettHand API Library, Examples, and Demos from the provided source files. The necessary third party headers and libraries (CTB serial port library, POCO, and wxWidgets) are included in the Windows installer to reduce the effort in compiling the source files for the hand with MinGW and Visual C++ 2008. The instructions for building these libraries from source code are included below. Windows XP or later is required (32-bit version) and the Peak drivers for the USB to CAN adapter.

MinGW “Minimalist GNU for Windows”

Install MinGW, “Minimalist GNU for Windows” (GPL + public domain)

Download:
http://www.mingw.org -> Downloads -> Automated MinGW Installer (tested with version 5.1.4, released 2008-04-26)
Install:
- MinGW base tools
- g++ compiler
- MinGW Make
You will need to add the bin directory to your system’s search path:
Control Panel -> System -> Advanced -> Environment Variables -> System Variables -> Path, add “C:\MinGW\bin” (or your MinGW bin path)

Windows Build Instructions for Third Party Dependencies

Install and build third party open source dependencies for the BarrettHand API Library:

1) Build the CTB Serial Port library and set the CTB environment variable

Install SED from http://gnuwin32.sourceforge.net/packages/sed.htm
Locate and run the script build_ctb.bat in “C:\Program Files\Barrett Technology\BHand\ThirdParty”
- This script will automatically issue “mingw32-make -f makefile.gcc DEBUG=0 GPIB=0” to build the CTB library

2) Build the POCO library

Find the source code:

Locate the source code in “C:\Program Files\Barrett Technology\BHand\ThirdParty”
Download the “The Economy Package” source code from http://pocoproject.org/

Example:

Copy POCO library to “C:\poco-1.3.6p2”
Set the POCO_BASE environment variable to be “C:\poco-1.3.6p2”
If you do not have Gawk for Windows download it from http://gnuwin32.sourceforge.net/packages/gawk.htm and install it
Download MSYS (tested MSYS-1.0.11) from http://www.mingw.org and install it
Launch MSYS (from the icon on the desktop) and issue

CD C:/poco-1.3.6p2 ./configure --config=MinGW --no-tests --no-samples --omit=XML,Util,Net make -s -j4 Foundation-libexec

At this point you may compile the examples and/or continue building dependencies for the GUI.

If you want to build the BarrettHand Control GUI from the source files you will need to build these third party open source dependencies:

3) Build the wxWidgets library (tested with 2.8.11)

Find the source code:

Locate wxMSW-2.8.11-Setup.exe windows installer in “C:\Program Files\Barrett Technology\BHand\ThirdParty”
Download wxMSW with the installer for Windows from http://www.wxwidgets.org/

The debug and release libraries still need to be built for MingGW. Follow these steps:

Edit wxWidgets-2.8.11\include\wx\msw\setup.h and change the #define wxUSE_GLCANVAS 0 to #define wxUSE_GLCANVAS 1
Also change the line that defines wxWIN_COMPATIBILITY from 1 to 0
Open a command prompt and issue the following commands
CD C:\wxWidgets-2.8.11\build\msw
mingw32-make -f makefile.gcc SHARED=0 UNICODE=0 USE_OPENGL=1
mingw32-make -f makefile.gcc SHARED=0 BUILD=release UNICODE=0 USE_OPENGL=1
Set the WXWIN environment variable to be C:\wxWidgets-2.8.11 or the correct path

4) Setup MinGW to include Glut header file

You may find the GLUT binaries for development (version 3.7.6) in the ThirdParty\glut-3.7.6-bin directory.

Place glut.h in C:\MinGW\include\GL

Notes:

This instruction was taken from the guide for using GLUT with the MinGW compiler at http://www.mingw.org/wiki/HOWTO_Use_Mark_J_Kilgards_OpenGL_Utility_Toolkit_GLUT_with_MinGW
The file glut32.lib is in the “ThirdParty\glut-3.7.6-bin” directory and the glut32.dll is in the copied to the system directory during installation.

Building the Examples

To build or rebuild Monitor Strain, RealTime, and Supervisory examples run the “make_examples” batch file located in the examples directory. The examples do not require the BarrettHand API Library because they include the BarrettHand source files.

Alternatively, to build directly from the command prompt:

CD to the example directory (examples/supervisory, examples/realtime, etc)
Issue: “mingw32-make ARCH=windows” to build the example

Note: The POCO_BASE environment variable must be set to the directories of these dependencies.

Code Blocks IDE

Code Blocks is a cross platform IDE that may be used to build the BarrettHand Control GUI and/or the BarrettHand API Library.

Download the binary release WITHOUT MinGW from http://www.codeblocks.org/downloads

1) To build the BarrettHand Control GUI

Open the CodeBlocks project file BHControl
Select the build target: Build -> Build Target -> Windows Debug
Build by clicking Build -> Build and Run or press F9

2) To build the BarrettHand API Library

Open the CodeBlocks project file BHand
Select the build target: Build -> Build Target -> Windows Release
Build by clicking Build -> Build

Note: If the POCO or wxWidgets dependencies were installed to other locations you will need to modify the CodeBlocks project files so that the header and library files can be found.

Building the Demos

To build bhdemo45 and Force Response demos run the “make_demos” batch file located in the demos directory. The demos require the BarrettHand API Library and also illustrate it being used in a Makefile.

To build a single demo from the command prompt:

CD to the demo directory (demos/bhdemo45, demos/ForceResponse, etc)
Issue: “mingw32-make ARCH=windows” to build the demo

Note: The POCO_BASE environment variable must be set to the directories of these dependencies.

Visual C++ 2008 Express Edition

If you don’t have Visual C++ and would like to use the express edition then you may download it from:

http://www.microsoft.com/express/Downloads/#2008-Visual-CPP -> Visual Studio 2008 Express -> Free Download

The following build instructions should be sufficient to build third party dependencies required by the BHControl Visual Studio Solution. However, they were tested on a system setup for using the MinGW compiler for building all the software described above.

Build wxWidgets:

Open Windows Explorer and open wxWidgets-2.8.11\build\msw\wx.dsw
Select Build -> Configuration Manager -> Active solution configuration -> Release
Right-click Solution ‘wx’ and do Build Solution (do this twice so that all projects are built)
Set the WXWIN environment variable to be C:\wxWidgets-2.8.11 or the correct path

Build the POCO library:

Navigate to C:\poco-1.3.6\Foundation
Open Foundation_vs90.vcproj
Select Build -> Configuration Manager -> Active solution configuration -> release_shared
Right-click the Foundation project and then Build
Copy C:\poco-1.3.6\bin\PocoFoundation.dll to C:\Windows\system32

Build the CTB library (optional step - you should already have this lib):

Navigate to ctb-0.14\build
run nmake -f makefile.vc DEBUG=0 GPIB=0

Open BHControl.sln which should be located in C:\Program Files\Barrett Technology\BHand\BHControl

Select the Release configuration (debug build of the GUI in Visual Studio does not build)
Right-click BHControl project in Solution Explorer and select Build

1.7 BHControl (C++) Software Setup - Linux

Ubuntu/Debian

The BarrettHand software version 4.4.x will run in Linux under the 32-bit version of Ubuntu 9.10. This software is installable with a Debian package, which contains the source code and precompiled binaries that are ready to run the demos, examples, and GUI for these versions of Ubuntu. Double-clicking on the Debian package will download and install all dependencies automatically and is the easiest way to get started running and developing software for the BarrettHand quickly. If you are not running Ubuntu version 9.10, which this software was tested with, it may be possible to build the GUI, demos, and examples from the BarrettHand source code provided in the “tgz” compressed version of the software.

Using the BarrettHand software and notes for the Debian Package

In the past the Debian package has been compiled to run on Ubuntu 7.10 and some of these notes are left here. However, there aren’t newer versions of wxWidgets available that are needed for the BHControl GUI for Gutsy (Ubuntu 7.10). Barrett is not planning on generating a Debian installer packages for older versions of Ubuntu. In addition to the build-essential package the BarrettHand Debian software package contains dependencies on libwxgtk2.8-d and libglut3-dev for the Control GUI. Ubuntu 9.10 has repositories to download these but if you are using Ubuntu 7.10 then you will need to add additional repositories to the end of /etc/apt/sources.list in order to install the BarrettHand software with the Debian package. Instead of editing this file by hand you may goto System -> Administration -> Software Sources -> Third Party Software and add these lines one at a time.

deb http://old-releases.ubuntu.com/ubuntu/ gutsy main universe multiverse

deb http://old-releases.ubuntu.com/ubuntu/ gutsy-updates main universe multiverse

deb http://old-releases.ubuntu.com/ubuntu/ gutsy-security main universe multiverse

If the BarrettHand software is installed using the Debian package it will be in the directory:

/usr/local/Barrett/BHand

If you have installed the software with the Debian package you should be all set to run an example. To do so, open a terminal and issue:

cd /usr/local/Barrett/BHand/examples/Supervisory

./Supervisory

The example should start and will ask for a COM port. Hit “1” and the enter key for /dev/ttyS0 (or a different number for other com ports). See the notes further below if you are using a USB to serial adapter. There are other demos and examples to try in the BHand directory. If the software was installed with the Debian package then you will have the build-essential package installed on your system and will be able to rebuild the example by issuing:

make clean

make

When you have the GUI installed and are ready to run it, open a terminal and issue:

cd /usr/local/Barrett/BHand/bhcontrol

./BHControl

The CodeBlocks package is required to build or rebuild the GUI and can be downloaded and installed with Synaptic Package Manager in Ubuntu 9.10. In the future there may be additional support for other IDEs like Eclipse. On Ubuntu 7.10 you will have to download the sources online from http://www.codeblocks.org/downloads. In addition, if you are using Ubuntu 7.10, you will need to download and install libgtk2.0-dev using Synaptic Package Manager in order to compile CodeBlocks. The older version of !Codeblocks 8.02 was found to be available at: http://www.codeblocks.org/downloads/6. Extract the package to the desktop and from a terminal issue these commands to build and install CodeBlocks:

cd Desktop/codeblocks-8.02-src

./configure

make -j4

make install

ldconfig

You may rebuild the BarrettHand Control GUI or the API library with CodeBlocks but to do so may require the appropriate permissions to modify files in /usr/local/Barrett (at least for Ubuntu 9.10). Running CodeBlocks as root will solve issues with permissions and allow you to rebuild the GUI.

To build or rebuild the BarrettHand Control GUI:

Start CodeBlocks by either:
- Launching it in Applications -> Programming -> Code::Blocks IDE
- Opening a terminal and issuing: sudo codeblocks
Open the CodeBlocks project file BHControl (in /usr/local/Barrett/BHand/bhcontrol/BHControl.cbp)
Select the build target: Build -> Build Target -> Linux Release
Click Build -> Build and Run or press F9

The binary for the API library is not required to build the Control GUI. Presently, it is only used to build the demos to illustrate how to use a Makefile to build from the API library instead of including “bhand.cpp”.

To build or rebuild the BarrettHand API Library:

Open the CodeBlocks project file BHand in the API directory
Select the build target: Build -> Build Target -> Linux Release
Build by clicking Build -> Build

Additional Info for BarrettHand Libraries, Headers, and Makefiles

The Debian package will install binaries for libraries that are dependencies for the BarrettHand in /usr/local/lib. The library files, which are required third party dependencies for controlling the hand, that are automatically installed by the BarrettHand software are:

libctb-barrett-0.14.a

libctb-barrett-0.14.so

libPocoFoundationBarrett.so

Notice that the filenames for the third party CTB and POCO libraries have been renamed to include “barrett” or “Barrett” in order to not stomp on a users installation of the CTB or POCO libraries. Barrett did not want it to be possible that the BarrettHand software would overwrite the users libraries so we renamed them to make sure they were unique. When developing these applications users should link to these libraries (in /usr/local/Barrett/BHand/thirdparty/lib or the copies of these in /usr/local/lib). However, the required header files are only available in /usr/local/Barrett/BHand/thirdparty/include. See the examples, which show how a Makefile may include and link the required third party headers and libraries along with the BarrettHand source code file “bhand.cpp” and header file “bhand.h”. If you would rather link to the BarrettHand library instead of including the “bhand.cpp” source file in a Makefile then take look at the demos that illustrate how to do that.

Compressed “tgz” file

The rest of this file describes how to build the BarrettHand Control GUI, BarrettHand API Library, Examples, and Demos from the provided source files for Ubuntu with the compressed tgz file. These instructions are not necessary if installing on Ubuntu 7.10 or 9.10. For these platforms it is recommended to install the BarrettHand Software with the provided Debian package, which will download dependencies so that you can get started with running and developing software for the BarrettHand quickly. In case you don’t want to install the BarrettHand software with the Debian package below are alternative installation instructions to get started with the software provided in the .tgz file for the BarrettHand software.

GNU C++ Compiler

If you do not already have the build-essential package installed then you may install it from a terminal using the following line:

sudo apt-get install build-essential

Installing Third Party Dependencies for Ubuntu

Install and build third party open source dependencies for the BarrettHand API Library:

1) Build the CTB Serial Port library included by Barrett (Location: thirdparty/sources/ctb-0.14). It is necessary to use the version supplied by Barrett in Linux.

Open a terminal and issue the commands

cd thirdparty/sources/ctb-0.14/build

make DEBUG=0 GPIB=0

sudo su

make DEBUG=0 GPIB=0 install

ldconfig

Also, in order to use the CodeBlocks IDE project files without changes, you will need rename the CTB libraries. Rename these by issuing these commands:

cd /usr/local/lib

mv libctb-0.14.a libctb-barrett-0.14.a

mv libctb-0.14.so libctb-barrett-0.14.so

2) Build the POCO library. Version 1.3.6 is the version that was tested and is included in thirdparty/sources). You should also be able to download the latest version if you wish.

Simple instructions are provided that will work for most users that do not already have a version of POCO installed. If a different version of POCO is installed already see below for notes on how to setup a special minimal copy of POCO just for the BarrettHand.

Do one of the following:

Download libpoco-dev using Synaptic Package Manager (version 1.3.3 or later)
Get a copy of the POCO source files (version 1.3.3 or later). Use the version provided or download “The Economy Package” source code from http://pocoproject.org/download/

Unpackage poco into a temporary directory

gunzip poco-X.Y.tar.gz

tar -xf poco-X.Y.tar

cd poco-X.Y

You only need to Build only the libraries that the BarrettHand Software requires

./configure --no-tests --no-samples --omit=XML,Util,Net

make -s -j4 Foundation-libexec

Install POCO to /usr/local

sudo make -s Foundation-libexec install

Also, in order to use the CodeBlocks IDE project files without changes, you will need rename the POCO library. Rename it by issuing these commands:

cd /usr/local/lib

mv libPocoFoundation.so libPocoFoundationBarrett.so

Notes on having multiple versions of POCO: If you want to have a separate version of POCO just for the BarrettHand then don’t execute sudo make -s Foundation-libexec install. Instead, copy the header files to a location outside of /usr/local/include and include them when you build the API. Also, rename the libPocoFoundation.so as shown above. That file can be copied to /usr/local/lib manually.

At this point you may compile the examples or continue the building dependencies for the GUI.

If you want to build the BarrettHand Control GUI from the source files you will need to build these third party open source dependencies:

3) Install the wxWidgets library (2.8.10 or later)

Open Synaptic Package Manager found in System -> Administration

Select the following package and install it

libwxgtk2.8-dev

4) Install OpenGL and GLUT

Open Synaptic Package Manager found in System -> Administration

Select and install the following package

libglut3-dev

Building the Examples

To build Monitor Strain, RealTime, and Supervisory examples open a terminal. The examples do not require the BarrettHand API library binary and instead directly include the BarrettHand source files.

In the terminal:

CD to the example directory (examples/supervisory, examples/realtime, etc)
Issue: “make” to build the example
Run it with “./Supervisory” or whatever the output name is

Code Blocks IDE

Code Blocks is a cross platform IDE that may be used to build the BarrettHand Control GUI and/or the BarrettHand API Library.

Open Synaptic Package Manager found in System -> Administration

Select the following package and install it

codeblocks

1) To build and run the BarrettHand Control GUI

Start CodeBlocks by launching it in Applications -> Programming -> Code::Blocks IDE
Open the CodeBlocks project file BHControl (in /usr/local/Barrett/BHand/bhcontrol/)
Select the build target: Build -> Build Target -> Linux Debug
Click Build -> Build and Run or press F9

2) To build the BarrettHand API Library

Open the CodeBlocks project file BHand in the API directory
Select the build target: Build -> Build Target -> Linux Debug
Build by clicking Build -> Build

Building the Demos

To build bh45demo and ForceResponse demos first create the BarrettHand static library. Follow the directions above for the CodeBlocks IDE and how to build the BarrettHand API Library.

To build a single demo from the terminal:

CD to the demo directory (demos/bh45demo, demos/ForceResponse, etc)
Issue: “make” to build the demo

Hardware Notes

The BarrettHand API uses the CTB library for a cross-platform serial port library. It only uses the names /dev/ttyS0, /dev/ttyS1, etc. If you want to use a USB to Serial adapter then one way to do that would be to create a symbolic link from a Terminal:

rm /dev/ttyS0

ln -s /dev/ttyUSB0 /dev/ttyS0

To verify a serial connection with the Hand that is not dependent on the GUI you may use Minicom that may be downloaded with Synaptic Packet Manager. It is a program for Linux that is similar to Hyperterminal. Configure the baud rate, device name (“/dev/ttyS0”, “/dev/ttyUSB0”, etc.), and verify that commands such as “HI” can be sent to the hand. Start minicom from a terminal with:

minicom -s

To actually make the USB to serial adapter work after a reset, one way is to create a script as shown below and add it to /etc/init.d

#! /bin/sh

rm /dev/ttyS0

ln -s /dev/ttyUSB0 /dev/ttyS0

and run:

update-rc.d myusbtoserial.sh defaults

Installing PCAN

The Debian package will install the PCAN USB adapter automatically. If you are installing the driver yourself, you may follow these steps to use the PCAN driver:

Create a symbolic link to the kernel header files
cd /usr/src

uname -r (to find out which linux kernel is being used)

ls (check to ensure the headers are available for this kernel, PCAN requires /usr/src/linux/include/linux/verson.h)

If you do not already have the symbolic link “linux” you may create it with:

ln -s linux-headers-2.6.31-14-generic linux (substitute your linux header’s directory)

Make and install PCAN library
cd peak-linux-driver-6.20

make NET=NO

su -c “make install”

Load the PCAN loadable kernel module
cd driver

sudo modprobe pcan

Launching BHControl GUI ()

Launching BHControl may require a known display and you may see an error similar to the one below.

Xlib: extension “GLX” missing on display “:0.0”. Xlib: extension “GLX” missing on display “:0.0”. freeglut OpenGL GLX extension not supported by display ‘:0.0’

Try to install graphics drivers so that OpenGL will work for the GUI. A search online for your version of Ubuntu and the graphics manufacturer will probably return useful information for installing these graphics drivers. If you have Ubuntu 7.10 and an Nvidia card, you may try the Envy GUI found with the following link: http://linuxgamingtoday.wordpress.com/2008/01/24/install-nvidia-drivers-using-envy-in-ubuntu.

1.8 Warranty & Subscription Support Contract Policies

Please see this document² for the latest version of Barrett’s policy.

2 User Manual

2.1 Safety and Cautions

PLEASE READ THIS SECTION IN ITS ENTIRETY BEFORE USING YOUR BarrettHand™.

Following these safety instructions will help prevent user injury and equipment damage.
As with any piece of robotic equipment, it is ultimately up to you to be aware of your surroundings during robot operation. The workspace of the system comprising the BarrettHand™ and robot arm should be clearly marked to prevent persons or objects from inadvertently entering the equipment’s reach. Before attaching the BarrettHand™, test host robot trajectories to confirm that it will not inadvertently collide with other objects in the workspace.
NEVER connect or disconnect any electrical cables while the Power Supply is turned on. Failure to follow this instruction could impart irreparable damage to the onboard electronics or put you at risk of electrical shock.
Always plug the Power Supply into a properly grounded wall source. Failure to do so could damage the BarrettHand™ electronics and put you at risk of electrical shock.
Do not place any part of your body or delicate objects within the grasp of the BarrettHand™ without first verifying control of the unit and confirming appropriate force levels.
Do not allow the BarrettHand™ to be exposed to liquids that may cause electrical short-circuit and put you at the risk of electrical shock.
Keep dirt away from the exposed gear and cable drives located at the joints.
Do not exceed the load limit of the fingers, 2 kg per finger. Consider all loading situations including accelerated loads, cantilever loads from long objects, robot collisions, active loads, etc.
Remove/replace the fingers only as instructed in the user manual and on this wiki.
Monitor the operating temperature of the BarrettHand™ so that it does not exceed 65C. Under normal conditions, the Hand operates between 40 and 60C. The BarrettHand™ was designed with non-backdrivable finger joints to take advantage of the motors’ peak operating performance in short bursts. The spread, however, is backdrivable to aid in target-independent grasping and requires constant motor current to actively hold position. Idling the spread motor, when possible, will help keep the temperature lower.

2.2 Low-level Message Format

This document describes the CAN message format used in Barrett products.
https://web.barrett.com/support/Puck_Documentation/CAN_Message_Format.pdf

2.3 Supervisory Control

The BarrettHand API is designed to provide capabilities of what was offered in previous hands and more. The new 280 hand contains Puck 2 motor properties that are written or read through a host PC connected with CAN nodes contained in the hand. The API is meant bring all functionality available to users without the need to know the low-level CAN communication protocol. The same BarrettHand Control GUI connects to all BarrettHands and uses the same Supervisory control interface. The same API methods are called. The GUI provides the purpose/notes of most properties that users will commonly access. See the API documentation for how to use commands in C++ code.

The BH8-280 hand implements each of the important commands found in the earlier BH8-Series hands to offer compatibility. These commands are found in the new hand:

Movement commands: C, HI, HOME, IO, IC, LOOP, M, O, T, TC, TO
Motor property commands: FSET, FGET, FLOAD, FSAVE, FDEF
Global property commands: PSET*, PGET*
Administrative commands: RESET

Note that PSET and PGET are commands for setting and getting global property values. The 280 hand will set all properties to the given value for PSET commands and will return -9 for a PGET command. The API does contain some virtual properties like the global “LFT” loop feedback temperature property. Virtual properties are read and written to variables on the host PC. The following commands have been left out for the 280 hand and probably won’t be available because there is no interactive mode via command prompt or global properties.

Motor property commands: FLIST, FLISTV
Global property commands: PLOAD*, PSAVE*, PDEF, PLIST, PLISTV
Global property commands:
Administrative commands: ?, ERR, VERS
Advanced commands: a?, FLISTA, FLISTAV, PLISTA, PLISTAV

The hand API provides a special “Command” method for processing a subset of the Grasper Control Language (GCL) character strings containing commands and returns a response to commands in a user supplied receive buffer. The string is parsed into commands that may contain a motor string prefix and possibly some parameters. This allows significant backwards compatibility and allows sending commands in the form of strings and receiving responses from the hand in the form of a string. A list of the presently accepted strings include “RESET” and:

“HI”
“C”, “O”
“M <optional position parameter>”
“HOME”
“IC <optional step size parameter>”, “IO <optional step size parameter>”
“TC”, “TO”
“FSET <property> <value>”
“FGET <property>”
“FLOAD, FSAVE, FDEF”
“T”
“LOOP”

The list of properties available on 280 hands is a subset of Puck 2 hand properties and virtual properties such as the ones that contain RealTime variables. Refer to the RealTime section for more information on RealTime properties. The API contains documentation for 262 and 280 hands in separate source code files for each hand. The documentation is easily accessible through the supervisory tab of the BarrettHand Control GUI. The programmer no longer needs to flip through this manual to find hand properties and their purpose, descriptions, notes, etc. The property list that each hand contains provides several useful attributes such as being read-only, global, and also a range of values that is used to validate inputs to some commands.

2.4 RealTime Control

RealTime mode, also known as Loop-Control mode, is the second control method for the BarrettHand™. This control mode allows you to send control data and receive feedback data continuously, without waiting for the motors to stop moving. Any desired control law can be implemented within the host computer by calculating the desired motor control reference, sending the control block with the control reference to the hand, waiting for the requested feedback data, and then repeating this update process. The control bandwidth is a function of the amount of control data sent, the amount of feedback data requested, and how fast the communication is.

Control data from the host computer to the hand is grouped into control blocks; feedback data is grouped into feedback blocks. The structure of the control and feedback blocks is set by various finger and global properties. These are mostly Boolean flags but some are integer coefficients. The structure can only be changed in Supervisory mode; it cannot be changed while in RealTime mode. The BH8-280 hand operates similarly by setting a desired control reference and then sending a batch Get property for each feedback property that is to be received.

Overview of Serial Protocol

To enter RealTime mode, the host computer sends the Supervisory mode “LOOP” command, with an optional motor prefix specifying the motors to be controlled. The hand responds with an acknowledgment character (“*”), and then awaits control blocks, with or without control data. When a control block is received, if the control block requests a feedback block, then transmission of the feedback block is started. Once the complete control block is received it is acted upon, and then the hand waits for the next control block. The host should not send a second control block until the first one is acknowledged.

If the Hand software encounters an error, then the next time the Hand would send the “*” acknowledgment character to the host it instead sends “<CRLF>ERR” followed by the error value. It then returns to Supervisory mode.

To terminate RealTime mode, the host should send a single C character instead of the header character. This returns the Hand to Supervisory mode.

Control and Feedback Blocks

Control and feedback blocks consist of a header character, followed if desired by control data. If control data is included then it is sent for each motor selected for the LOOP command, in motor number order, followed by any global datum. For each motor, any of a set of data can be included. Whether or not a specific piece of data should be included is controlled by one of ten flag properties: “LCV”, “LCPG”, “LCT”, “LFAIN”, “LFBP”, “LFV”, “LFS”, “LFAP”, “LFDP” and “LFT.” If a given property is true then its corresponding datum is included in the block; if not, then it is omitted. Four other properties, “LCVC”, “LFVC”, “LFDPC”, and “LFDPD”, modify specific data items.

Control Blocks

Control data from the host to the hand is grouped into control blocks. Each control block has a single byte header, optionally followed by a set of control data. The header specifies whether or not control data is to follow, and whether or not a feedback block is to be returned. The header can also terminate RealTime mode.

The possible header byte values are:

‘C’ Control data follows; respond with a feedback block
‘c’ Control data follows; respond with an acknowledgment character
‘A’ No control data follows; respond with a feedback block
‘a’ No control data follows; respond with an acknowledgment character
<C> Terminate RealTime mode

If the ‘C’ or ‘c’ header is used, then the header should be followed by control data. The user needs to choose the control mode themselves by setting LCV and LCPG flags to 1 or 0. If either of these are 1 then LCT must be 0 and if LCT is 1 then LCV and LCPG must be 0. Only one active control mode per motor is allowed. For each motor, the following different data values should be included in order if their corresponding flags are true:

LCV “Loop Control Velocity” Signed, 1 byte
LCPG “Loop Control Proportional Gain” Unsigned, 1 byte
LCT “Loop Control Torque” Signed, 2 bytes

The control data should be sent in a specific order: first all data for motor 1, then all for motor 2, then motor 3, and finally motor 4. Note that if a given motor was not specified in the initiating LOOP command, or if a specific value isn’t enabled by the corresponding finger property, then the corresponding datum should not be transmitted.

If the LCV datum is included, then the hand will multiply it by the property LCVC before passing it on to the motor. Note: the hand treats an unscaled LCV datum as 4 bits of integer and 4 bits of fraction; this is different from an unscaled LFV datum, which is all integer.

Feedback Blocks

Data from the hand to the host is grouped into feedback blocks. Each feedback block has a single byte header (“*”), followed (if requested) by a set of feedback data. If the hand has encountered an error, then the header is replaced by “<CRLF>ERR “, followed by the error number; the hand then returns to supervisory command mode.

For each selected motor, six different data values are included in order if their corresponding finger properties are non-zero:

LFV “Loop Feedback Velocity” Signed, 1 byte
LFS “Loop Feedback Strain” Unsigned, 1 byte
LFAP “Loop Feedback Absolute Position” Unsigned, 2 bytes
LFDP “Loop Feedback Delta Position” Signed, 1 byte
LFBP “Loop Feedback Breakaway Position” Unsigned, 2 bytes
LFAIN “Loop Feedback Analog Input” Unsigned, 1 byte

In addition to the motor feedback data, there is a single global feedback datum, which is sent if its corresponding global property is non-zero:

LFT “Loop Feedback Temperature” Signed, 1 byte

The feedback data are sent in a specific order: first all data for motor 1, then all for motor 2, then motor 3, then motor 4, then any global datum. Note that if a given motor was not specified in the initiating LOOP command, or if a specific value isn’t enabled by the corresponding finger or global property, then the corresponding datum is not transmitted.

If the LFV datum is included, then the hand will divide it by the property Loop LFVC before sending it to the host. Note: the hand treats an unscaled LFV datum as all integers; this is different from an unscaled LCV datum, which is treated as 4 bits of integer and 4 bits of fraction.

Loop Feedback Delta Position

The LFDP (“Loop Feedback Delta Position”) datum is a special case. Each time a motor’s position is queried using “FGET P”, the reported position is remembered. In loop mode, if the LFDP property is non-zero then the present position is read and compared to the previously reported position. The difference is divided by the LFDPC (“Loop Feedback Delta Position Coefficient”) property, clipped to a single signed byte, and then sent to the host. The host should then multiply the received value by LFDPC and then add it to the reported position.

The problem with using delta position is that the reported position can change at most by +127/-128 in each cycle. If the motor position changes more than this in a single cycle then the reported position will lag behind the actual position.

Example: say LFDPC is 2, the last reported position was 1500, and the position suddenly jumps to 2000. The first feedback block will include the delta position datum 127, which actually means 254; the hand will internally update the reported position to 1754. The next feedback block will include the delta position 123, which actually means 246; the reported position will be updated to 2000. Subsequent feedback blocks will include the delta position value 0 (until the next position change).

If desired, any unreported position change can be discarded by setting the LFDPD (“Loop Feedback Delta Position Discarded”) global property to true. With this set, the above example would result in the single value 127 being sent to the host, followed by 0s.

Property Summary

Table 4 and Table 5 is a summary of the different motor and global properties, which affect RealTime mode. Most of the properties are flags, specifying whether a specific datum is to be present in a control or feedback block. The four remaining properties are coefficients or flags, which affect how the firmware interprets or generates a datum.

Table 4 - RealTime Finger Control Properties for the BH8-262

Property	Name	Type	Function	Size in Block
LCV	Loop Control Velocity	Flag	If True, RealTime control block will contain control velocity	1 signed byte
LCVC	Loop Control Velocity Coefficient	Coefficient (1 to 255)	LCV is multiplied by LCVC to determine control velocity	N/A
LCPG	Loop Control Proportional Gain	Flag	If True, RealTime control block will contain Proportional Gain	1 unsigned byte
LCT	Loop Control Torque	Flag	If True, RealTime control block will contain control torque	2 bytes, signed
LFAIN	Loop Feedback Analog Input	Flag	If True, RealTime feedback block will contain analog input value	1 unsigned byte
LFBP	Loop Feedback Breakaway Position	Flag	If True, RealTime feedback block will contain breakaway position	2 unsigned bytes
LFV	Loop Feedback Velocity	Flag	If True, RealTime feedback block will contain feedback velocity	1 signed byte
LFVC	Loop Feedback Velocity Coefficient	Coefficient (1 to 255)	Actual velocity is divided by LFVC to get LFV	N/A
LFS	Loop Feedback Strain	Flag	If True, RealTime feedback block will contain strain information	1 unsigned byte
LFAP	Loop Feedback Absolute Position	Flag	If True, RealTime feedback block will contain absolute position	2 unsigned bytes
LFDP	Loop Feedback Delta Position	Flag	If True, RealTime feedback block will contain delta position	1 signed byte
LFDPC	Loop Feedback Delta Position Coefficient	Coefficient (1 to 255)	The actual delta position is divided by this to get LFDP	N/A
LFDPD	Loop Feedback Delta Position Discard	Flag	If true, any delta position overflow is discarded	N/A

Table 5 - RealTime Global Control Properties

Property	Name	Type	Function	Size in Block
LFT	Loop Feedback Temp.	Flag	If True, RealTime feedback block will contain temperature	1 unsigned byte

Example

This application uses fingers 1 and 2, and the spread. The fingers will receive velocity control information and report strain and delta position. The spread will just report delta position. The feedback block will also include the present hand temperature. All relevant coefficients will be set to 1.

To set this, use the following commands:

12FSET LCV 1 LCVC 1 LCPG 0 LCT 0 LFV 0 LFS 1 LFAP 0 LFDP 1 LFDPC 1

4FSET LCV 0 LCT 0 LCPG 0 LFV 0 LFS 0 LFAP 0 LFDP 1 LFDPC 1

PSET LFT 1

124LOOP

The hand will then send a single “*” and wait for control blocks. Each control block will consist of three bytes:

“C” [Control data follows; respond with feedback block]
1 signed byte of velocity for motor 1
1 signed byte of velocity for motor 2

Each feedback block will consist of seven bytes:

”*”
1 unsigned byte of strain for motor 1
1 signed byte of delta position for motor 1
1 unsigned byte of strain for motor 2
1 signed byte of delta position for motor 2
1 signed byte of delta position for motor 4
1 unsigned byte of temperature

Each control block from the host will stimulate a feedback block from the hand. When the host is finished, it will send the single character

2.5 Kinematics, joint ranges, conversion factors

Finger Drivetrain and TorqueSwitch™

It is easiest to understand Barrett’s patented TorqueSwitch™ mechanism by first understanding the operation of the BarrettHand finger assembly. Figure 1 shows a single finger, including all critical drive elements, with the motor windings and rest of the hand hidden.

Figure 1 - Single BarrettHand Finger Assembly

Figure 2 is a close-up of the drive elements in the finger. During normal operation, the 16-tooth motor pinion (gray) drives both the 30-tooth distal (yellow) and 40-tooth proximal (blue) gears, which transmit power through their respective right-handed, single-start worms (red and green) and into two 50-tooth worm gears (orange and purple). The proximal worm gear (purple) is tied directly to the proximal link with six screws, whereas the distal gear (orange) connects to the distal link via mechanical cables. The net result is a motion ratio of 125:1 for the motor shaft to proximal joint position and a 93.75:1 reduction for the motor shaft to distal joint position. Also, note the two magnets (light blue) and their associated Hall-array sensors (black) at the ends of the motor shaft and worm shaft. The magnets are magnetized N/S radially, rather than axially, which allows the Puck (motor controller) to determine the position of both joints in the finger via the Hall-array sensors.

Figure 2 - BarrettHand Finger Drive Elements

The connection between the proximal worm (green), the belleville washers (pink) and the proximal gear (blue) is the critical part of this assembly that makes the TorqueSwitch™ work. The proximal gear is internally threaded, and rides on right-handed threads cut into the worm shaft, while the belleville washers are compressed between the side of the gear and a shoulder on the shaft. The compressed bellevilles create Coulomb friction in the assembly that holds the gear stationary relative to the worm.

When the proximal link contacts a surface, the resultant torque in the worm causes the gear to “break away” from the Coulomb friction and wind off the washers along the shaft. Figures 3 through 5 show this process.

Figure 3 - Finger drivetrain pre-breakaway

The worm and proximal gear rotate together at first, linked across the belleville washers via Coulomb friction.

Figure 4 - Proximal gear winding off bellevilles

When the proximal link encounters adequate resistance torque, the friction breaks away and the proximal gear winds off the belleville washers. From this point forward, the proximal link remains locked in place.

Figure 5 - Finger drivetrain post-breakaway

The proximal gear then winds up the worm shaft, directing motor torque to drive the distal link. The threaded shaft is long enough to allow full range-of-motion for the distal link in any scenario. All motor torque is directed to the distal link until the bellevilles are re-engaged by reversing the motor.

The TorqueSwitch™ is reset by opening the finger. First, the distal link will open as the proximal gear winds along the shaft, then drive the proximal gear against the belleville washers, re-engaging the clutch and causing the proximal link to open with the distal link. When the proximal link encounters a resistive force, such as its joint stop, the proximal gear will compress the bellevilles, preloading the system to a programmable level (Puck parameter “OT”).

Figure 6 can be used to set OT (the factory default is 0). The force shown in this graph is applied to an object held about half way up the proximal link when the breakaway torque is reached. In other words, it is a measure of how hard the proximal links are grasping when the torque switch activates. Because of variance in the coefficient of friction, some adjustment may be necessary for your application.

Figure 6 - Breakaway Force Curve

To control how much force is applied to an object being grasped without sensor feedback such as finger-tip torque sensors (strain gauges) or tactile sensors, the MT property must be used. Please see Figure 7 to see how MT and finger torque are related:

Figure 7 - Motor Torque vs. Property “T”

Optional Strain Gage Joint-Torque Sensor

The strain gauges measure the torque about the outer link of each finger. If your BarrettHand includes this option, you will be able to query the SG property to get the present strain gauge value. This value is a number between 0 and 4095, corresponding roughly to a fingertip force of -2 to +2 kg. A finger without any force applied should report an SG value of around 2000 when the strain gauge option is installed.

The full SG curve is here:http://web.barrett.com/support/BarrettHand_Documentation/BH8-280_StrainGageCalibration.pdf

The HSG and LSG properties set the High Strain Gauge and Low Strain Gauge limits. For example, if you set HSG to 3000 before you issue a movement command that closes the finger, that finger will stop moving at the moment the SG value reaches 3000 (~1 kg). Likewise, if you set LSG to 1000 before you issue a movement command that opens the finger, that finger will stop moving at the moment the SG value reaches 1000 (~1 kg against the back of the finger).

The fingers also have a “self-preservation” feature. When the torque about the outer link exceeds 1.14 Nm (SG < 667 or SG > 3460), the finger will automatically drive itself to minimize the fingertip force. If you wish to disable this feature, you can set HSG to the special value of 10000. This will not change HSG, it will simply turn off self-preservation. If you want to re-enable the self-preservation feature, you can set HSG to the special value of 10001.

Spread Motion

The spreading action of fingers F1 and F2 on the BarrettHand™ increases the dexterity of the entire unit with only one additional actuator. Optimal grasp configurations can be achieved “on-the-fly” without costly tool changes associated with traditional grippers. In addition, the backdrivability built into this degree of freedom causes the BarrettHand™’s grasp shape to change in mid-grasp, creating a more stable grasp of oddly shaped target objects.

Should you wish to control the spread position of the fingers, the complete command set available to the fingers is also available for the spread, including commands for fixed-increment motion and move-to-position commands.

The sustainable torque that the spread fingers can exert continuously in a ‘pinch’ type grasp is shown in Figure 33. These are found by changing the FPG property while keeping all other properties at their defaults. For a given torque setting, larger forces can be achieved by curling F1 and/or F2 closed to the point where the contact point becomes closer to the spread axis.

Figure 33 - Pinch Grasp Torque

Forward Kinematics

The forward kinematics for the BarrettHand™ were determined using the Denavit - Hartenberg notation described in “Introduction to Robotics, Mechanics and Control 2nd Edition”, John J. Craig. Each finger is considered its own manipulator and is referenced to a wrist coordinate frame in the center of the palm. Use the forward kinematics calculated in this section to determine fingertip position and orientation with respect to the palm.

Equation 1 - Homogeneous Transform Between Frame {i-1} and {i}

The forward kinematics are determined using the following equation:

Equation 2 - Forward Kinematics from Wrist Frame to Fingertip

Table 8 is a list of the parameter values used to compute the forward kinematic transformation matrices for all of the fingers.

All of the kinematics for the BarrettHand™ are derived from the zero position. The configuration of the fingers and spread in the zero position of the BarrettHand™ is shown in Figure 36 along with the wrist coordinate frame.

Figure 36 - BarrettHand™ in Zero Position

Finger Kinematics:

Figure 37 - D-H Frame Assignment for Generalized Finger

Table 9 - D-H Link Parameters for Fingers

Where: “k” is defined as the desired finger [1,2,3].

“r” is either [-1,1,0] for [F1,F2,F3] respectively.
“j” is either [1,1,-1] for [F1,F2,F3] respectively.

The transforms from each axis to the next can be determined using the homogeneous transform in Equation 1 and finger link parameters in Table 9. Each of the first three link parameters are fixed and the fourth one is configuration dependent on one of the position variables Θk1, Θk2, or Θk3 for the first three joints.

It is useful to check that the multiplication of the four transformation matrices matches for a given finger and at least one hand configuration, such as the zero position. The computed homogeneous transformation matrix from the wrist to tool frame for a finger is:

Equation 3 - Forward Kinematics Matrix for a Finger

The hand configuration is determined using position feedback from the encoders. The number of encoder ticks and availability of inner link joint encoders depends on the model number of the hand. The following are the hand positions in units of radians before the TorqueSwitch™ is activated:

Notice that Θk3 will generally move 1/3 the amount of Θk2 but after the TorqueSwitch™ has been activated the inner link stops moving and all the joint torque is applied to the outer link. Users that have inner link joint position sensors will be able to determine finger joint positions at all times. For earlier hands without inner link position sensors it may be possible to estimate joint positions after detecting breakaway. This section is concerned with equations for forward kinematics and does not attempt keeping track of finger joint positions all the time. Once the outer finger link stops on hands without inner link position sensors after TorqueSwitch™ activation, the joint positions and end tip position cannot be accurately determined until the TorqueSwitch™ mechanism is reset. It may be reset by opening the finger. Refer to Appendix B for information on how to detect TorqueSwitch™ activation.

The finger end tip positions are found in the WTT matrices in the last column. Discarding the 1 in the last row, you have the Cartesian X end tip coordinate in the first row, the Y coordinate in the 2nd row, and the Z coordinate in the 3rd row.

Joint Properties

Encoder to Joint Ratios

This section describes all mechanical reductions in the 262, 280 and 282 hands as well as the ratios that go from finger and spread encoder positions to joint positions in units of radians. To find the finger or spread mechanical reduction relative to the motor use the constants in the table below. Table 10 applies to the hands before breakaway occurs. Each finger has 3 joints starting with the knuckle joint that swings the spread, the last one moves the outer link, and the one in between moves an amount proportional to the outer link until breakaway occurs. To go from motor encoder position to actual finger position for joint 2 multiply the encoder position by the corresponding joint Radians to ticks ratio. Joint 3 of the finger moves one third this amount. This transformation works before breakaway of the TorqueSwitch™ has occurred.

Table 10 - Finger and Spread Joint RatiosThe optical encoders for each of the 280 and 282 hand motors have 4096 count encoders and 262 hand motors uses a 90 line, or 360 count, encoder. Inner link encoders are the same ones used on the motor for position feedback.

The forward kinematics from section 9.5, that are used to calculate end-tip positions, depend on the configuration of joint positions for each finger (joint 2 and joint 3) and the spread. Calculate positions in radians for each joint including spread, finger joint 2, and finger joint 3. These will be the joint positions before breakaway.

Joint 3 position can be represented more precisely if it is calculated relative to the plane of the palm plate that is accurate before and after breakaway. This position for joint 3 depends only on the model number (262, 280 or 282) of the hand where 3 is a joint 3 offset from joint 2 equal to approximately 42°.

Equation 4 - Joint 3 Positions Before and After Breakaway

Note that joint 1 in the knuckle drives the outer link first through a 93.75 reduction and then a 4:1 reduction. The motor position directly determines the outer link angle with the palm plate of the hand as shown in Equation 4. During breakaway joint 2 position needs to be detected in software by using breakaway acceleration threshold for the 262 hand and then this link remains motionless as described in section 9.3. The breakaway position may be used for finding where breakaway occurred. Joint 3 position still only depends on just absolute motor position. On 280 and 282 hands, the inner-link joint position sensors may be used together with the outer link position to determine the finger positions at all times.

Joint Motion Limits

The maximum joint motion limits for the BarrettHand™ are calculated based on the zero position seen in Figure 36. Depending on the position of the spread joint, Θ11, and the objects in the grasp, the maximum joint motion limits for the finger links may vary.

The inner link, Θ12, Θ22, Θ32, has a maximum joint motion limit of 140° with no object blocking movement and Θ11 in the full close or open position. The outer link, Θ13, Θ23, Θ33, has a maximum joint motion limit of 48° when Θ11 is fully open or closed and there is no object in the grasp, as shown in Figure 38. When the spread is in any position other than full open or close, the fingers may not have the full range of motion due to interference with other fingers.

Figure 38 - Finger Joint Motion Limit Range

The spread joint, Θ11, has a maximum joint motion limit of 180° with no object blocking movement and all fingers in the full open position. If the fingers are partially closed or there is an object in the grasp, Θ11 may be restricted due to finger interference. See Figure 39.

Figure 39 - Spread Joint motion limit Range

2.6 Technical Specifications {#2.6-technical-specifications}

Kinematics

Total fingers: 3 Fingers which spread: 2 Joints per finger: 2 Motors per finger: 1 Axes of palm spread motion: 2 Motors for palm spread motion: 1 Total hand axes: 8 Total hand motors: 4

Range of Motion

Finger base joint: 140° Fingertip: 45° Finger spread: 180°

Finger Speed

Finger fully open to fully closed:1.0 sec Full 180° finger spread: 0.5 sec

Position Sensing

Type: optical incremental encoder Resolution: 0.008° at the finger base joint 17,500 encoder counts full finger open to full close

Weight

978 g (2.15 lb)

Optional Arm Adapter B0133: 0.2 kg (0.4 lb) additional

Payload

6.0 kg (13.2 lbs), 2.0 kg (4.4 lb) per finger

Finger Forces (at tip) {#finger-forces-(at-tip)}

Active: 15 N (3.3 lb) Passive: 20 N (4.4 lb)

Motor Type

Rare-Earth , brushless, DC, servo motors

Mechanisms

Worm drives integrated with patented cable drive and breakaway clutch

Cycles per Month

10,000

Power Requirements

AC electrical outlet

Load: 440 W

Phases: Single

Voltage: 120/240 VAC (85-264 Vrms)

Frequency: 50/60 Hz (47-63 Hz)

Power Supply

Location: dry, stationary surface

Size H,W,D:

295 x 145 x 40 mm

(11.8 x 5.7 x 1.7 in)

Weight : 1.3 kg (3.4 lb)

Single Cable to Hand

3m continuous-flex cable, 8mm diameter

Hand Dimensions, BH8-282 {#hand-dimensions,-bh8-282}

http://web.barrett.com/supportFiles/wikiFiles/Dimensions_282.png

Available Options

B029A Strain gage Fingertip Torque Sensors for all three fingers
B0111 C++ Function Library
B01C3 Subscription Service

US Patents (patents established and pending in other countries) {#us-patents-(patents-established-and-pending-in-other-countries)}

5,501,498
5,388,480
4,957,320

2.7 Mounting Plate Part Drawing {#2.7-mounting-plate-part-drawing}

Please find the part drawing for the mounting plate attached here³.

2.8 Wiring Diagrams {#2.8-wiring-diagrams}

Bottom Connector

The BH8-282 Bottom Connector is a 10 pin Hirose, Part number H2853-ND

The proper mating connector housing is a Hirose DF11-10DS-2C.

Typical sockets include Hirose DF11-2428SC (application and wire-gauge dependant).

All available at http://www.digikey.com/

Pin	Signal
1	48V
2	Power GND
3	User line 1 (USB 5V)
4	User line 2 (USB data-)
5	RS232TX/CANH
6	RS232RX/CANL
7	User line 3 (USB data+)
8	User line 4 (USB GND)
9	Earth ground
10	No Connection

Side Connector

The BH8-282 Side Connector is a 10 pin Hirose, Part number H2868-ND at http://www.digikey.com/

The proper mating connector housing is a Hirose DF11-10DS-2C.

Typical sockets include Hirose DF11-2428SC (application and wire-gauge dependant).

All available at http://www.digikey.com/

Pin	Signal
1	48V
2	Power GND
3	User line 1 (USB 5V)
4	User line 2 (USB data-)
5	RS232TX/CANH
6	RS232RX/CANL
7	User line 3 (USB data+)
8	User line 4 (USB GND)
9	Earth ground
10	No Connection

Strain Gauge Pogo Pin Block

Two missing attachments

Tactile Sensor Pogo Pin Block

Two missing attachments

Power Connector

Please find the part drawing for the power connector attached here.

Power Supply DB9 Connector

The BH8-280 hand Power supply has two DB9 Connectors, one male and one female

DB9 Male

Pin	Signal
1	User line A
2	NC
3	User line C
4	NC
5	NC
6	User line B
7	NC
8	User line D
9	NC

DB9 Female

Pin	Signal
1	NC
2	CAN H or RS232 RX
3	RS232 TX
4	NC
5	Ground
6	NC
7	CAN L
8	NC
9	NC

2.9 Inertial Tensors and Mass Properties for the BarrettHand BH8-282 {#2.9-inertial-tensors-and-mass-properties-for-the-barretthand-bh8-282}

The inertial properties calculated here represent the masses and inertias of each link of the BarrettHand BH8-280. All calculations were made using SolidWorks 2013 SP 3.0 and CAD models that include all mechanical components of the hand (including fasteners) and all electrical components except wiring. To verify that the SolidWorks model was correct, assemblies and parts of an actual hand were massed for comparison.

The mass of an actual finger was measured at 179 g, which matches the mass of the CAD model. The hand base (including pucks and finger motors) measured 388 g while SolidWorks calculated the mass of the CAD model to be only 367 g. This discrepancy could come from a number of sources:

Lack of wiring in CAD
Lack of grease in CAD
Inadequately modeled PCB and components

Further investigation narrowed the source of error to electrical subassemblies with dozens of strands of wire, all of which were omitted in the CAD model. To replicate the mass of these wires, slugs of the missing mass were created to fill the cavities in which wires could run. The base CAD model used in the calculations below measures 367 g.

In the following images, all parts are left transparent to display all parts of the mass calculations. Yellow denotes frame parts, red denotes electrical pieces, and blue is for motors and drivetrain components.

The following inertial frames are established on the hand. In each of the following diagrams, coordinate systems are oriented with the Z-axis coincident to the axis of rotation of each joint. These inertial frames follow the same convention as on the BarrettHand BH8-262.

Since no one is likely to wish to attempt computed-torque control on the Hand axes (since the frictions in the Hand are very high), the backdriven, reflected drive inertias of the drives were not computed. Since backdriven drive inertias have no effect on gravity terms, the frame inertias should give you good results for controlling the WAM arm and wrist torques as functions of hand-finger positions.

You may also view mass properties of the entire hand in various configurations here: http://web.barrett.com/support/BarrettHand_Documentation/BarrettHand280MassProp-2010Dec10.pdf

Mass Properties for Frame W (hand base frame) with palm pad {#mass-properties-for-frame-w-(hand-base-frame)-with-palm-pad}

Output coordinate System: Frame W (opaque)

Mass = 0.36699 kilograms

Volume = 0.00011798 cubic meters

Surface area = 0.18541 square meters

Center of mass: (meters)

X = -2.506e-005 Y = 0.034479 Z = -.0072785

Principal axes of inertia and principal moments of inertia: ( kilograms * square meters ) Taken at the center of mass.

Ix = (0.0018855, -0.15008, 0.98867)	Px = 0.00021984
Iy = (-0.21340, -0.96595, -0.14623)	Py = 0.00040405
Iz = (0.97696, -0.21070, -0.033849)	Pz = 0.00040831

Moments of inertia: ( kilograms * square meters ) Taken at the center of mass and aligned with the output coordinate system.

Lxx = 0.00040811	Lxy = 0.00000082	Lxz = 0.00000048
Lyx = 0.00000082	Lyy = 0.00040009	Lyz = -0.00002736
Lzx = 0.00000048	Lzy = -0.00002736	Lzz = 0.00022400

Moments of inertia: ( kilograms * square meters ) Taken at the output coordinate system.

Ixx = 0.00086379	Ixy = 0.00000051	Ixz = 0.00000055
Iyx = 0.00000051	Iyy = 0.00041950	Iyz = -0.00011939
Izx = 0.00000055	Izy = -0.00011939	Izz = 0.00066026

Mass Properties for Frame W (hand base frame) without palm pad {#mass-properties-for-frame-w-(hand-base-frame)-without-palm-pad}

Output coordinate System: Frame W (opaque)

Mass = 0.34867 kilograms

Volume = 0.00010856 cubic meters

Surface area = 0.16889 square meters

Center of mass: ( meters )

X = -2.63759e-005 Y = 0.033662 Z = -0.0087593

Principal axes of inertia and principal moments of inertia: ( kilograms * square meters ) Taken at the center of mass.

Ix = (0.0017695, -0.19274, 0.98124)	Px = 0.00020570
Iy = (0.81607, 0.56738, 0.10998)	Py = 0.00037703
Iz = (-0.57794, 0.80057, 0.15830)	Pz = 0.00037892

Moments of inertia: ( kilograms * square meters ) Taken at the center of mass and aligned with the output coordinate system.

Lxx = 0.00037765	Lxy = 8.17141e-007	Lxz = 4.70601e-007
Lyx = 8.17141e-007	Lyy = 0.00037187	Lyz = -3.26426e-005
Lzx = 4.70601e-007	Lzy = -3.26426e-005	Lzz = 0.00021211

Moments of inertia: ( kilograms * square meters ) Taken at the output coordinate system.

Ixx = 0.00079952	Ixy = 5.07559e-007	Ixz = 5.51157e-007
Iyx = 5.07559e-007	Iyy = 0.00039862	Iyz = -0.00013545
Izx = 5.51157e-007	Izy = -0.00013545	Izz = 0.00060722

Mass Properties for Frame 1 (finger spread frame) {#mass-properties-for-frame-1-(finger-spread-frame)}

Output coordinate System: F1 (opaque)

Mass = 0.14109 kilograms

Volume = 3.919e-005 cubic meters

Surface area = 0.058268 square meters

Center of mass (meters):

X = 0.030616 Y = -7.3219e-005 Z = -0.011201

Principal axes of inertia and principal moments of inertia (kilograms * square meters), taken at the center of mass:

Ix = (-0.99149, -0.0047957, -0.13013)	Px = 1.9838e-005
Iy = (0.13011, 0.0033343, -0.99149)	Py = 6.904e-005
Iz = (0.0051888, -0.99998, -0.0026819)	Pz = 7.4106e-005

Moments of inertia (kilograms * square meters), taken at the center of mass and aligned with the output coordinate system:

Lxx = 2.0672e-005	Lxy = 2.6024e-007	Lxz = 6.3481e-006
Lyx = 2.6024e-007	Lyy = 7.4105e-005	Lyz = 1.7118e-008
Lzx = 6.3481e-006	Lzy = 1.7118e-008	Lzz = 6.8207e-005

Moments of inertia (kilograms * square meters), taken at the output coordinate system:

Ixx = 3.8374e-005	Ixy = -5.604e-008	Ixz = -4.2034e-005
Iyx = -5.604e-008	Iyy = 0.00022405	Iyz = 1.3283e-007
Izx = -4.2034e-005	Izy = 1.3283e-007	Izz = 0.00020045

Mass Properties for Frame 2 (finger inner link frame) without fingertip torque sensor {#mass-properties-for-frame-2-(finger-inner-link-frame)-without-fingertip-torque-sensor}

Output coordinate System: F2_Origin

Mass = 0.05832 kilograms

Volume = 1.629e-005 cubic meters

Surface area = 0.026068 square meters

Center of mass (meters):

X = 0.022042 Y = 0.00082603 Z = 0.0005526

Principal axes of inertia and principal moments of inertia (kilograms * square meters), taken at the center of mass:

Ix = (-0.99971, -0.016746, 0.017324)	Px = 4.7372e-006
Iy = (0.016611, -0.99983, -0.007873)	Py = 4.1939e-005
Iz = (0.017453, -0.0075829, 0.99982)	Pz = 4.3077e-005

Moments of inertia (kilograms * square meters), taken at the center of mass and aligned with the output coordinate system:

Lxx = 4.7592e-006	Lxy = 6.2295e-007	Lxz = -6.6417e-007
Lyx = 6.2295e-007	Lyy = 4.1929e-005	Lyz = -2.1644e-009
Lzx = -6.6417e-007	Lzy = -2.1644e-009	Lzz = 4.3066e-005

Moments of inertia (kilograms * square meters), taken at the output coordinate system:

Ixx = 4.8168e-006	Ixy = 1.6848e-006	Ixz = 4.6191e-008
Iyx = 1.6848e-006	Iyy = 7.0281e-005	Iyz = 2.4457e-008
Izx = 4.6191e-008	Izy = 2.4457e-008	Izz = 7.144e-005

Mass Properties for Frame 2 (finger inner link frame) with fingertip torque sensor {#mass-properties-for-frame-2-(finger-inner-link-frame)-with-fingertip-torque-sensor}

Output coordinate System: F2_Origin

Mass = 0.062139 kilograms

Volume = 1.7634e-005 cubic meters

Surface area = 0.028654 square meters

Center of mass (meters):

X = 0.023133 Y = 0.00078642 Z = 0.00052792

Principal axes of inertia and principal moments of inertia (kilograms * square meters), taken at the center of mass:

Ix = (-0.99972, -0.015048, 0.018278)	Px = 4.7942e-006
Iy = (0.014917, -0.99986, -0.0073066)	Py = 4.3325e-005
Iz = (0.018386, -0.0070319, 0.99981)	Pz = 4.4454e-005

Moments of inertia (kilograms * square meters), taken at the center of mass and aligned with the output coordinate system:

Lxx = 4.8162e-006	Lxy = 5.7981e-007	Lxz = -7.2483e-007
Lyx = 5.7981e-007	Lyy = 4.3317e-005	Lyz = -2.6653e-009
Lzx = -7.2483e-007	Lzy = -2.6653e-009	Lzz = 4.4441e-005

Moments of inertia (kilograms * square meters), taken at the output coordinate system:

Ixx = 4.872e-006	Ixy = 1.7103e-006	Ixz = 3.4041e-008
Iyx = 1.7103e-006	Iyy = 7.6588e-005	Iyz = 2.3133e-008
Izx = 3.4041e-008	Izy = 2.3133e-008	Izz = 7.7733e-005

Mass Properties for Frame 3 (fingertip frame) without fingertip pressure pad {#mass-properties-for-frame-3-(fingertip-frame)-without-fingertip-pressure-pad}

Output coordinate System: F3 (opaque)

Mass = 0.041377 kilograms

Volume = 1.5627e-005 cubic meters

Surface area = 0.019684 square meters

Center of mass (meters):

X = 0.022825 Y = 0.0010491 Z = 0.00042038

Principal axes of inertia and principal moments of inertia (kilograms * square meters), taken at the center of mass:

Ix = (-0.99921, -0.032055, 0.023536)	Px = 3.0842e-006
Iy = (0.023767, -0.0068431, 0.99969)	Py = 1.568e-005
Iz = (-0.031884, 0.99946, 0.0075995)	Pz = 1.6826e-005

Moments of inertia (kilograms * square meters), taken at the center of mass and aligned with the output coordinate system:

Lxx = 3.1053e-006	Lxy = 4.3996e-007	Lxz = -2.9595e-007
Lyx = 4.3996e-007	Lyy = 1.6812e-005	Lyz = -1.8205e-008
Lzx = -2.9595e-007	Lzy = -1.8205e-008	Lzz = 1.5673e-005

Moments of inertia (kilograms * square meters), taken at the output coordinate system:

Ixx = 3.1582e-006	Ixy = 1.4308e-006	Ixz = 1.0106e-007
Iyx = 1.4308e-006	Iyy = 3.8376e-005	Iyz = 0
Izx = 1.0106e-007	Izy = 0	Izz = 3.7275e-005

Mass Properties for Frame 3 (fingertip frame) with fingertip pressure pad {#mass-properties-for-frame-3-(fingertip-frame)-with-fingertip-pressure-pad}

Output coordinate System: F3 (opaque)

Mass = 0.04166 kilograms

Volume = 1.5911e-005 cubic meters

Surface area = 0.02168 square meters

Center of mass (meters):

X = 0.02295 Y = 0.0010739 Z = 0.00041752

Principal axes of inertia and principal moments of inertia (kilograms * square meters), taken at the center of mass:

Ix = (-0.99919, -0.032581, 0.023483)	Px = 3.0982e-006
Iy = (0.023724, -0.0070039, 0.99969)	Py = 1.5816e-005
Iz = (-0.032406, 0.99944, 0.0077712)	Pz = 1.6962e-005

Moments of inertia (kilograms * square meters), taken at the center of mass and aligned with the output coordinate system:

Lxx = 3.1199e-006	Lxy = 4.5115e-007	Lxz = -2.9813e-007
Lyx = 4.5115e-007	Lyy = 1.6948e-005	Lyz = -1.8635e-008
Lzx = -2.9813e-007	Lzy = -1.8635e-008	Lzz = 1.5809e-005

Moments of inertia (kilograms * square meters), taken at the output coordinate system:

Ixx = 3.1752e-006	Ixy = 1.4779e-006	Ixz = 1.0106e-007
Iyx = 1.4779e-006	Iyy = 3.8897e-005	Iyz = 0
Izx = 1.0106e-007	Izy = 0	Izz = 3.78e-005

3 Maintenance

3.1 Troubleshooting {#3.1-troubleshooting}

Most of the symptoms repeated in this section were generated by Barrett’s own lab Hands which are assigned to destructive testing over millions of cycles.

Symptom: Initial strain gage values do not fall within specified range.

Possible Solution:

The strain gage balancing potentiometer needs to be readjusted⁴.
Verify the cable is riding across both the top and the bottom of the idler pulley, as shown in Figure 25.
If the problem persists, contact Barrett Technology.

Figure 25 - Cable and Idler Pulley

Symptom: The strain gage values do not follow the expected strain gage curves, shown in Figure 35, while grasping.

Possible Solution:

The finger cable pretension is not adjusted properly. [Set the finger cable pretension properly⁵.](http://support.barrett.com/wiki/Hand/280/FingerCablePretensioning)
The strain gage balancing potentiometer needs to be readjusted⁶.
Verify the cable is riding properly on the idler pulley, as shown in Figure 25.
Verify idler pulley rotates freely on the shoulder screw. The shoulder screw should not be tightened against the idler pulley. If so, loosen shoulder screw, shown in Figure 25, so the idler pulley will move with cable motion.
If the problem persists, contact Barrett Technology.

Symptom: Only the fingertip closes when the entire finger should close (Premature Breakaway).

Possible Solution:

Verify there is no object blocking the inner link from moving.
The finger was not opened completely. Restore that fingers OT, IVEL, IOFF, and IHIT to their default values. Initialize the finger having the problem. The finger should now close properly.
If the problem persists, contact Barrett Technology.

Symptom: Finger sticks fully closed.

Possible Solution:

Verify there are no objects or other fingers blocking the finger from opening completely.
The open velocity is too slow. Try increasing the open velocity to greater than or equal to 40 and opening the finger.
Verify that the strain gage value SG is less than HSG (High Strain Gage Limit; alias is MSG).
If the strain gages are not installed, set HSG to 256 for the BH8-262.
The finger cable pretension is too high. [Set the finger cable pretension properly⁷.](http://support.barrett.com/wiki/Hand/280/FingerCablePretensioning)
Set the open velocity greater than or equal to 40 and then initialize the finger.
[Reload firmware⁸.](http://support.barrett.com/wiki/Hand/280/FirmwareUpdate)
If the problem persists, contact Barrett Technology.

Symptom: Finger sticks open.

Possible Solution:

Verify there are no objects or other fingers blocking the finger from closing.
The close velocity is set too low. Try increasing the close velocity to greater than or equal to 40 and closing the finger.
Set the close velocity to greater than or equal to 40 and then initialize the finger.
Reload firmware.
If the problem persists, contact Barrett Technology.

Symptom: Finger moves in opposite direction of commanded motion.

Possible Solution:

Reload firmware.
There is an encoder feedback problem. Reinitializing the finger should solve the immediate problem. If this recurs, contact Barrett Technology for servicing.

Symptom: The TorqueSwitch™ does not breakaway properly, prohibiting the fingertip from completing a form grasp around an object.

Possible Solution:

The close velocity is too slow. Increase the close velocity greater than or equal to 40.
Reinitialize the finger; this may reset the TorqueSwitch™.
If the BarrettHand™ has been inactive for an extended period or if the finger has been slammed open against its stop with a high velocity setting, the TorqueSwitch™ may need to be manually activated. Insert a 2-mm hex wrench into the left Drive Access hole, as shown in Figure 27. Rotate counterclockwise to open the finger fully. Next, press very hard against the inner link to constrain it from moving while not constraining the outer link, as the person’s thumb is doing in Figure 26, while torqueing the hex wrench clockwise. Increase torque until the fingertip breaks free, so that it can be rotated easily while the inner link remains stationary. Remove the 2-mm hex wrench and reinitialize the finger.
If the problem persists, contact Barrett Technology.

Figure 26 - Manual Torque Switch Activation

Figure 27 - Manual TorqueSwitch™ Activation Drive Holes

Symptom: Fingers will not close completely.

Possible Solution:

Adjust close target CT so that it is either at or just beyond the actual palm surface.
Verify that the outer link has not broken away prematurely.
Verify proper finger angles when the fingers are removed and replaced during lubrication maintenance. An error here can cause the outer finger link to reach its joint stop prematurely, even without breakaway, before either CT or the inner finger-link joint limit is reached. Verify finger angle is correct by [disconnecting and reattaching fingers⁹.](http://support.barrett.com/wiki/Hand/280/LubricationAndFingerReplacement) Readjust if necessary.
Verify there are no objects or other fingers blocking the finger from closing completely.
Verify the MSG (Maximum Strain Gage) property is greater than the strain gage value (SG). If the strain gages are not installed, set MSG to 256.
If the problem persists, contact Barrett Technology.

Symptom: The spread motion has excessive friction.

Possible Solution:

[Lubricate the spread motor gears¹⁰.](http://support.barrett.com/wiki/Hand/280/LubricationAndFingerReplacement)
If the palm screws have been reinstalled, verify all screws are tightened with the same amount of torque. Excessive torque may cause spread friction.
If the problem persists, contact Barrett Technology.

Symptom: The threaded locking ring does not fit on the threaded base of the BarrettHand™.

Possible Solution:

The threaded locking ring has been damaged or is warped. Contact Barrett Technology for a replacement part.
The threads on the base of the BarrettHand™ have been damaged. Contact Barrett Technology for service.

Symptom: The fingertip flops over backwards after a severe impact against a finger tip.

Possible Solution:

The finger cable is broken. Verify this by removing the Shroud Cover, see Figure 23, and inspecting the cable. The cable should be intact and not broken. If the cable is broken, contact Barrett Technology.

Symptom: The fingertip has excessive backlash.

Possible Solution:

The pretension in the cable is too low. [Set the finger cable pretension properly¹¹.](http://support.barrett.com/wiki/Hand/280/FingerCablePretensioning) If the problem persists, contact Barrett Technology.
The finger cable is broken. Verify this by removing the Shroud Cover, see Figure 23, and inspecting the cable. The cable should be intact and not broken. If the cable is broken, contact Barrett Technology.

Figure 23 - Shroud Cover

Symptom: The fingertip has driven itself open beyond the normal full-open position and perhaps is hyperextended, but it is not loose. {#symptom:-the-fingertip-has-driven-itself-open-beyond-the-normal-full-open-position-and-perhaps-is-hyperextended,-but-it-is-not-loose.}

Possible Solution:

This can only happen if the spur-gear teeth are not properly engaged when the finger is reinstalled after being removed for lubrication. Verify that the finger is seated completely and square where it attaches to the palm. Verify also that the finger screw is in place and is not loose. Reset the fingertip angle and reseat the finger carefully and verify that it is seated completely and square. Test.
If the problem persists, Hand must be serviced.

Symptom: The spread fingers F1 and F2 are at different angles around the palm.

Possible Solution:

An internal spread gear is damaged and will need to be replaced. Contact Barrett Technology.

3.2 Finger Cable Pretension {#3.2-finger-cable-pretension}

The third joint in each finger is driven by a brushless servomotor through opposing stainless steel cables that act like tendons transmitting torque from a pulley at the base of the finger out to a pulley at the fingertip joint. If you have purchased the joint-torque sensor option, the difference in tension between the tendon pair is used to determine the torque at the third joint. The fact that we measure the tensions differentially reduces the effect of actual pretension in the cable as long as the cable is not actually loose.

Under normal circumstances, the cables remain pretensioned indefinitely. But under heavy use over thousands of cycles, it can begin to relieve its pretension. You can easily readjust the pretension through Barrett Technology’s patented cable tensioning mechanism as follows:

Loosen the hex set screw with the right angle hex wrench provided in the maintenance kit. This screw is located adjacent to the termination of the joint 3 cable on each of the fingers as seen in Figure 11.

Figure 11 - Hex set screw
Apply between 6oz-in and 8oz-in of clockwise torque to the tensioner screw located on the back of each Joint 3 housing as seen in Figure 12. A 2-mm hex torque wrench is provided in the maintenance kit for this purpose.
- CAUTION:
- The tendon is properly tensioned when all loose slack has been removed and you can feel the direct connection of the fingertip to its drive gears. DO NOT OVER-TIGHTEN THE TENDON! The pretensioning mechanism is stronger than the tendon and is capable of snapping it if over-tightened. Excessive pretension will change the frictional properties in the finger drives and may reduce the finger’s range of motion.
Re-tighten the hex set screw until it is snug against the tensioner screw.
- NOTE:
- It is advisable to completely remove the hex set screw to apply Loctite 222 to its threads before re-tightening it against the tensioner screw. This measure is especially important if the hand is under heavy use.

Figure 12 - Pretensioning the Tendon Cable

3.3 Lubrication {#3.3-lubrication}

Each BarrettHand™ unit has been lubricated and tested prior to shipping. Periodically, lubrication must be reapplied to areas with high probability of lubricant flow. Use the grease syringe to apply Mobil 1® Synthetic Grease (both included with the maintenance kit) to all exposed gear teeth at the application points according to Figure 14 and the schedule in Table 6.

Table 6 - Lubrication Schedule

Application Point	Maintenance Cycle
Finger Worm Gears	5000 cycles
Finger Spur Gears	5000 cycles
Finger Motor Spur Gears	5000 cycles
Palm Spur Gears	5000 cycles

Figure 14 - Lubricant Application Points

Lubricating the finger spur gears requires caution, because you must remove each finger from the palm assembly to access this application point. See the section below on how to detach, lubricate, and reattach the finger.

Finger Replacement

Read all steps below before conducting this maintenance. Pogo pins that connect to sensors in the hand may shear unless the finger is detached and reattached with care. It is best to lubricate only one finger at a time.

Step 1: Turn off power to Hand.

Step 2: Open all fingers on the BarrettHand and open the Spread completely (fingers 1 and 2 opposite finger 3). The fingers can be opened manually using a 2 mm hex wrench in the right-hand hole shown. See Figure 15.

Figure 15: Prepare BarrettHand

Step 3: Locate shoulder screw that connects the finger to the hand. See Figure 16.

Figure 16: Locate shoulder screw

Step 4: Using a 2 mm hex wrench, unscrew the shoulder screw. Turn the hand sideways and slap the base of the BarrettHand with your palm to get the shoulder screw to fall out.

Step 5: Slide the finger assembly up slightly (Figure 17a), then pivot it out (Figure 17b).

Figure 17: Gently lift and rotate finger off

If the joint-torque sensor option is installed, BE CAREFUL not to damage the gold-plated electrical contact pins when disengaging the teeth. Do not twist or rock the finger when removing or attaching it.

Step 6: Slowly pull finger away from the motor body.

Figure 18: Slowly pull finger away from motor body.

Step 7: Take the replacement finger and verify that the inner link is driven into its stop. Using a 2 mm hex wrench, insert it into the right-hand hole and rotate counter-clockwise until the finger stops moving. See Figure 19.

Figure 19: Adjust angle of 2nd link.

Step 8: Check/adjust the angle of the fingertip using the plexiglass finger-angle tool. Place the tool as shown (Figure 20). Using a 2 mm hex wrench, insert it into the left-hand hole and rotate until the finger stops up against the forward edge of the plexiglass tool.

For BH8-262 hands only: Should either link, or the spur gears to which they are attached, move after the finger has been removed, the fingertip position must be reset. Use a 2-mm hex wrench to manually rotate the Joint-3 drive 5 1/2 revolutions from the position where both links are inline and horizontal.

Figure 20: Check/adjust the finger angle

Step 9: If necessary, add Mobil 1® Synthetic grease to the motor body cavity using the syringe provided. Cover all gear teeth with a thick bead of grease. Reverse Steps 5 and 6 to attach the new finger. Be careful not to damage (shear) the electrical ÒpogoÓ pins at the base of the motor (Figure 21).

Figure 21: Close-up of electrical “pogo” pins

Step 10: Once the finger is in place, apply slight pressure down and screw in the shoulder screw. See Figure 22.

Figure 22: Apply downwards pressure and secure shoulder screw.

Step 11: Verify that the finger operates smoothly. Using a 2mm hex wrench in the right-hand hole (see Figure Error: Reference source not found), drive the finger manually through its range of motion.

Finger replacement is complete.

3.4 Fastener Check {#3.4-fastener-check}

All screw fasteners in the BarrettHand™ have been installed with a thread locker, which should prevent loosening over the life of the product. However, after prolonged use, Barrett Technology recommends that you conduct a precautionary inspection to ensure all external fasteners are in place and tight. Ideally, this inspection should occur monthly under heavy use conditions.

Should any fasteners have become dislodged during operation, contact Barrett Technology for replacements or replacement specifications. Do not replace fasteners without contacting Barrett Technology as many fasteners have strict length specifications.

Figure - Important Fastener Locations

3.5 BarrettHand BH8-282 Strain Gage Maintenance {#3.5-barretthand-bh8-282-strain-gage-maintenance}

Due to variations in materials, manufacturing and external forces, the strain gage values may change. These changes will affect the zero force reading for each beam differently. To maintain consistent results, the zero force reading needs to remain constant. Each strain gage is equipped with a balancing potentiometer. Adjusting the balancing potentiometer will change the strain gage output for that finger. Adjust the finger’s balancing potentiometer until the no-load value is between 100 and 140. Use the following steps to zero the strain gages:

Initialize the BarrettHand™.
Terminate the spread motor so it can be moved around the palm. (Issue the “T” command)
Remove the Shroud Cover screws shown in Figure 23. Some models of the BarrettHand™ will have four Shroud Cover screws. Remove the Shroud from the finger link.

Figure 23: Shroud Removal

BH8-282 users should run the program Monitor Strain. This program will continuously sample the strain gage values and print them to the screen. Another option is to run the BarrettHand Control GUI and poll for strain values.
Adjust the balancing potentiometer using a small flat head screwdriver until the desired value is reached. The balancing potentiometer requires very small adjustments, due to its sensitivity. Apply as little pressure as possible on the balancing potentiometer during adjustment. See Figure 24.

Figure 24: Balancing Potentiometer

After balancing the strain gage, exit the Monitor Strain program, put the shroud and shroud cover back on and secure the screws. Be careful not to touch the strain gage or damage any of the electrical wiring when replacing the shroud.

4 Programmer’s Manual

4.1 IDE Installation and Configuration - Ubuntu {#4.1-ide-installation-and-configuration—ubuntu}

Eclipse

The following installation instructions are for Eclipse CDT (C/C++ Development Tooling).

Eclipse CDT allows for syntax highlighting, auto-completion, visual debugging, easy source navigation as well as other useful tools.

Eclipse CDT can either be added to an existing Eclipse installation or installed from source. This tutorial will focus on the latter.

Download and Install Eclipse CDT Indigo for Developers:

Be sure to choose the correct version (32 or 64 bit from the right menu)

http://www.eclipse.org/downloads/packages/eclipse-ide-cc-developers-includes-incubating-components/indigosr1

Move the tarball to the installation directory of your choice for installation.

tar -zxvf yourfile.tar.gz
rm -rf yourfile.tar.gz

You should now be able to run eclipse.

cd eclipse
./eclipse

In order to start eclipse from the command line, your directory of choice must be in the unix PATH environment variable.

echo $PATH
#If the path is not present you can add it permanently with the following command.
echo ‘export PATH=”$PATH:/path_to/directory_of_choice/eclipse”’ >> ~/.bashrc && . ~/.bashrc
#You should now be able to start eclipse from the command line
eclipse

Creating Eclipse project files:

In the directory of the project file that you would like to export simply:

cmake . -G”Eclipse CDT4 - Unix Makefiles”

Importing generated Eclipse project files:

In Eclipse:

File --> Import --> General --> Existing Projects into Workspace --> Next --> Browse

Browse to your package’s root directory and hit OK

Finish the import by selecting the finish button.

Your project should now be imported into Eclipse and can be viewed in the Project Explorer on the left side of the IDE.

Other useful tools and plugins

Barrett Technology Auto Formatting

Download the BTech Automatic Formatting Template

#Navigate to a directory of choice
wget http://support.barrett.com/attachment/wiki/Common/IDE/BTech_Format.xml

In Eclipse:

Window–>Preferences–>C/C++–>Code Style–>Import Browse to your BTech_Format.xml and hit OK

Hit apply and OK.

Your Eclipse projects should now follow the Barrett Technology conventions.

To apply the formatting to an existing file:

Open file --> Source --> Format

Adding Python IDE for Eclipse - PyDev

PyDev is a great IDE for Python development.

PyDev also has much of the advantages of CDT; auto-completion, syntax highlighting, auto formatting, etc.

Note: the instructions are for Eclipse Indigo Help --> Eclipse Marketplace

Search for: PyDev or python. The first result will be PyDev.

Install PyDev. This may require restarting Eclipse.

You should now have all of the aforementioned python tools.

Installing Eclipse Color Themes

Eclipse color theme plugin allows for automatic color formatting of the IDE.

Note: the following instructions are for Eclipse Indigo Help --> Eclipse Marketplace

Search for: eclipse color theme. Install Eclipse Color Theme by Felix Dahlke and Roger Dudler.

After installation you can apply a color theme by: Window–>Preferences–>General–>Appearance–>Color Theme - choose the theme of your choice and apply.

http://support.barrett.com/chrome/site/bhand/280/figure26.png ↩
http://web.barrett.com/temp/Support_Contract_Policy_Mar-21-2019.pdf ↩
https://web.barrett.com/supportFiles/wikiFiles/B4283_Arm_Adapter_Drawing.PDF ↩
http://support.barrett.com/wiki/Hand/282/StrainGageMaintenance ↩
http://support.barrett.com/wiki/Hand/280/FingerCablePretensioning ↩
http://support.barrett.com/wiki/Hand/282/StrainGageMaintenance. ↩
http://support.barrett.com/wiki/Hand/280/FingerCablePretensioning ↩
http://support.barrett.com/wiki/Hand/280/FirmwareUpdate ↩
http://support.barrett.com/wiki/Hand/280/LubricationAndFingerReplacement ↩
http://support.barrett.com/wiki/Hand/280/LubricationAndFingerReplacement ↩
http://support.barrett.com/wiki/Hand/280/FingerCablePretensioning ↩

Share on

X Facebook LinkedIn Bluesky

Longsen Gao

BarrettHand BH8-282 Instruction

Table of Contents

1 Getting Started

1.2 BH8-282 System Components {#1.2-bh8-282-system-components}

In the Box

Additional Information

The Hand

Power Supply

Electrical Cables

Lab Bench Stand

Control Software and Firmware

System Options

Arm Adapter

Fingertip Torque Sensing Option

Tactile Sensing Option

1.3 BH8-282 Hardware setup

Initial Configuration

Mounting Method 1: Lab Bench Stand - demonstrated with a BH8-282 model

Mounting Method 2: On Robot Arm

Robot-Arm Adapter

Installing the Hand Cable on a Robot Arm

Electrical Connections

Power-Up Sequence

1.4 Software Setup

Host Computer

Installing BH8-SERIES Control Software

1.5 PyHand (Python) Setup for BarrettHand BH8-Series

Installation Instructions

1.6 BHControl (C++) Software Setup - Windows

MinGW “Minimalist GNU for Windows”

Windows Build Instructions for Third Party Dependencies

Building the Examples

Code Blocks IDE

Building the Demos

Visual C++ 2008 Express Edition

1.7 BHControl (C++) Software Setup - Linux

Ubuntu/Debian

1.8 Warranty & Subscription Support Contract Policies

2 User Manual

2.1 Safety and Cautions

2.2 Low-level Message Format

2.3 Supervisory Control

2.4 RealTime Control

Overview of Serial Protocol

Control and Feedback Blocks

Control Blocks

Feedback Blocks

Loop Feedback Delta Position

Property Summary

Example

2.5 Kinematics, joint ranges, conversion factors

Finger Drivetrain and TorqueSwitch™

Optional Strain Gage Joint-Torque Sensor

Spread Motion

Forward Kinematics

Joint Properties

Encoder to Joint Ratios

Joint Motion Limits

2.6 Technical Specifications {#2.6-technical-specifications}

Kinematics

Range of Motion

Finger Speed

Position Sensing

Weight

Payload

Finger Forces (at tip) {#finger-forces-(at-tip)}

Motor Type

Mechanisms

Cycles per Month

Power Requirements

Power Supply

Hand Dimensions, BH8-282 {#hand-dimensions,-bh8-282}

Available Options

US Patents (patents established and pending in other countries) {#us-patents-(patents-established-and-pending-in-other-countries)}

2.7 Mounting Plate Part Drawing {#2.7-mounting-plate-part-drawing}

2.8 Wiring Diagrams {#2.8-wiring-diagrams}

Bottom Connector

Side Connector

Strain Gauge Pogo Pin Block