This document will go over through all machine learning concepts with related examples in robotics to go over through all related topics to help every roboticist to solid the background in machine learning.

1. Linear Regression

1.1 what’s the linear regression?

Linearity: A relationship between two variables defined by a first-degree (linear) function. Graphically, this relationship is represented as a straight line.

Non-linearity: A relationship between two variables that is not a first-degree function. Consequently, its graphical representation is not a straight line.

Regression: When measuring phenomena, objective limitations often mean that we obtain “observed values” rather than the “true value.” To approximate the true value, one would theoretically perform an infinite number of measurements and use that data to calculate a path back to the truth. This process of “returning” or “regressing” to the true value from observed data is the origin of the term.

1.2 What Problems Can It Solve?

Linear regression is used to process large volumes of observational data to derive mathematical expressions that align with the underlying patterns of a phenomenon. In other words, it uncovers the inherent relationships within the data, allowing us to simulate outcomes and perform predictive analysis.

Essentially, it solves the problem of using known data to determine unknown results.

Common Applications:

• Real Estate: Predicting housing prices based on variables like square footage or location.
• Finance: Assessing credit ratings or risk levels.
• Entertainment: Estimating movie box office performance.

1.3 What is the General Expression?

The standard mathematical form for a simple linear regression model is: \(Y = wx + b\) In this expression:

• $ w $ ** (Coefficient): Also referred to as the **weight or slope, it represents the influence of the independent variable $x$ on the output $Y$.
• $ b $ (Bias Term): Also known as the intercept or offset, it represents the value of $Y$ when $x$ is zero.

User Manual

Barrett Technology Inc.

Table of Contents

1.1 Thank You 5

Improvements over the previous model (BH8-280): 5

1.2 BH8-282 System Components 5

In the Box 5

Additional Information 6

The Hand 6

Power Supply 7

Electrical Cables 8

Lab Bench Stand 9

Control Software and Firmware 9

System Options 10

Arm Adapter 10

Fingertip Torque Sensing Option 11

Tactile Sensing Option 11

1.3 BH8-282 Hardware setup 12

Initial Configuration 12

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

Mounting Method 2: On Robot Arm 14

Robot-Arm Adapter 14

Installing the Hand Cable on a Robot Arm 15

Electrical Connections 16

Power-Up Sequence 16

1.4 Software Setup 16

Host Computer 16

Installing BH8-SERIES Control Software 17

1.5 PyHand Setup for BarrettHand BH8-Series 17

Installation Instructions 17

1.6 Software Setup - Windows 17

MinGW “Minimalist GNU for Windows” 18

Windows Build Instructions for Third Party Dependencies 18

Building the Examples 19

Code Blocks IDE 20

Building the Demos 20

Visual C++ 2008 Express Edition 20

1.7 Software Setup - Linux 21

Ubuntu/Debian 21

1.8 Warranty & Subscription Support Contract Policies 30

2.1 Safety and Cautions 30

2.2 Low-level Message Format 31

2.3 Supervisory Control 31

2.4 RealTime Control 32

Overview of Serial Protocol 33

Control and Feedback Blocks 33

Control Blocks 33

Feedback Blocks 34

Loop Feedback Delta Position 35

Property Summary 35

Example 37

2.5 Kinematics, joint ranges, conversion factors 38

Finger Drivetrain and TorqueSwitch™ 38

Optional Strain Gage Joint-Torque Sensor 44

Spread Motion 45

Forward Kinematics 46

Joint Properties 50

Encoder to Joint Ratios 50

Joint Motion Limits 51

2.6 Technical Specifications 53

Kinematics 53

Range of Motion 53

Finger Speed 53

Position Sensing 53

Weight 53

Payload 53

Finger Forces (at tip) 53

Motor Type 53

Mechanisms 53

Cycles per Month 53

Power Requirements 54

Power Supply 54

Hand Dimensions, BH8-282 54

Available Options 54

US Patents (patents established and pending in other countries) 54

2.7 Mounting Plate Part Drawing 55

2.8 Wiring Diagrams 55

Bottom Connector 55

Side Connector 55

Strain Gauge Pogo Pin Block 56

Tactile Sensor Pogo Pin Block 56

Power Connector 56

Power Supply DB9 Connector 56

2.9 Inertial Tensors and Mass Properties for the BarrettHand BH8-282 57

Mass Properties for Frame W (hand base frame) with palm pad 58

Mass Properties for Frame W (hand base frame) without palm pad 60

Mass Properties for Frame 1 (finger spread frame) 61

Mass Properties for Frame 2 (finger inner link frame) without fingertip torque sensor 63

Mass Properties for Frame 2 (finger inner link frame) with fingertip torque sensor 66

Mass Properties for Frame 3 (fingertip frame) without fingertip pressure pad 67

Mass Properties for Frame 3 (fingertip frame) with fingertip pressure pad 68

3.1 Troubleshooting 70

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

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

3.2 Finger Cable Pretension 76

3.3 Lubrication 78

Finger Replacement 79

3.4 Fastener Check 84

3.5 BarrettHand BH8-282 Strain Gage Maintenance 84

4.1 IDE Installation and Configuration - Ubuntu 86

1 Getting Started

• 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:

1. BarrettHand™ Control GUI application and API,
2. Firmware (latest *.tek file), and
3. 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.

1. 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.
   
2. Screw on the threaded ring.
   
3. 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.
     
4. 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:

1. 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.
2. Verify the Hand Cable is plugged into the back of the Power Supply and into the bottom of the BarrettHand™.
3. Verify the AC line Line Cord cord is plugged into a valid power source and into the power outlet on the Power Supply.
4. Turn on the host computer.
5. Turn on the Power Supply. The main power switch is located on the back panel.
6. 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

1. Uninstall any old versions of PyHand.
2. 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
3. Execute the installer, and follow the on-screen prompts to complete. Be sure to install the PEAK USB-CAN driver when prompted.
4. 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)

1. Download:
   ​http://www.mingw.org -> Downloads -> Automated MinGW Installer (tested with version 5.1.4, released 2008-04-26)
2. Install:
   • MinGW base tools
   • g++ compiler
   • MinGW Make
3. 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:

1. CD to the example directory (examples/supervisory, examples/realtime, etc)
2. 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:

1. CD to the demo directory (demos/bhdemo45, demos/ForceResponse, etc)
2. 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:

1. CD to the example directory (examples/supervisory, examples/realtime, etc)
2. Issue: “make” to build the example
3. 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:

1. CD to the demo directory (demos/bh45demo, demos/ForceResponse, etc)
2. 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

Table 5 - RealTime Global Control Properties

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/

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/

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

DB9 Female

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:

1. Lack of wiring in CAD
2. Lack of grease in CAD
3. 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.

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