+

(http://robdobson.com/)
%
! (HTTP://ROBDOBSON.COM) SINGLE-ARM ROBOT

# (HTTP://ROBDOBSON.COM/2016/04/NON-VESTING-SHARE-OPTIONS/) $
(HTTP://ROBDOBSON.COM/2016/03/AUTO-REMINDER-WATCH/)

' Single-Arm Robot

http://robdobson.com/2016/03/single-arm-robot/ 1/24/17, 9?44 AM

Page 1 of 21
 Ive been contemplating this video (https://www.youtube.com/watch?v=32y3_iyHpBc) and others
like it and wanted to see if I could build a robot arm for playing games on phones. I started looking
at dual-arm SCARA robots but decided that a single arm would be better suited to the task as
there needs to be a camera looking at the phone screen and there is less to get in the way with a
single arm SCARA.

Looking for an open-source design to get started with I found one on Thingiverse
(http://www.thingiverse.com/thing:124149) which didnt look too complicated although, at the
time, nobody seemed to have made one. I got to work printing out the parts which took a couple
of days on my Ultimaker Original.
(http://robdobson.com/wp-content/uploads/2016/03/Scara-Arm-Testing2.jpg)

(http://robdobson.com/wp-
content/uploads/2016/03/47b37b70ae986bd9469e70a983e7e39c_preview_featured.jpg)

http://robdobson.com/2016/03/single-arm-robot/ 1/24/17, 9?44 AM

Page 2 of 21
 Unfortunately the parts didnt go together as easily as I would have liked mainly I think because
there was no allowance for tolerances in the original model design so, for instance, the space to
accommodate a 15mm outer diameter linear bearing was exactly 15mm in diameter. On my 3D
printer that isnt workable so I had to re-draw many of the parts (I used Rhino 3D) from the STL
meshes and increase the openings where needed.

I then had some trouble with the belts used to drive the arms. I wasnt able to find 160 teeth belts
cheaply in the UK so I bought some 158 teeth ones. They were, unsurprisingly, too tight so I had to
re-print the motor mount pieces with the holes moved.

I also found that the 320 teeth belt (which I did manage to source) was too tight. In this case I
solved the problem by re-creating a 60 tooth gear to replace the 62 tooth one in the original
design. I found a great SCAD template for this here (http://www.thingiverse.com/thing:16627)
and modified it accordingly.

Control Electronics
To control the steppers I used a pair of driver modules like this
(https://www.pololu.com/product/1182) which have a micro-stepping ability
(http://motion.schneider-electric.com/technology-blog/stepper-motor-basics-half-and-micro-
stepping/). This allows a conventional stepper motor (with 1.8 degrees of movement per step) to
be driven in increments of slightly over 0.1 degrees (actually 1.8/16 degrees).

For the controller I wanted to try out a MicroPython PyBoard (https://micropython.org/) I had
recently bought together with an LCD display and touch keypad (https://micropython.org/doc/tut-
lcd-skin). It didnt take much time to get to grips with and I can heartily recommend this as an
alternative to writing C++ for every little project.

http://robdobson.com/2016/03/single-arm-robot/ 1/24/17, 9?44 AM

Page 3 of 21
 (http://robdobson.com/wp-content/uploads/2016/03/Scara-Arm-Control.jpg)

Test Program

http://robdobson.com/2016/03/single-arm-robot/ 1/24/17, 9?44 AM

Page 4 of 21
 My simple test program worked fine to move the arms around by pressing the buttons on the
keypad.

Python
1 import pyb
2 import mpr121
3
4 # Pins used to control the stepper motor drivers
5 lowerArmStep = pyb.Pin('Y9', pyb.Pin.OUT_PP)
6 lowerArmDirn = pyb.Pin('Y10', pyb.Pin.OUT_PP)
7 upperArmStep = pyb.Pin('Y11', pyb.Pin.OUT_PP)
8 upperArmDirn = pyb.Pin('Y12', pyb.Pin.OUT_PP)
9
10 # Using a library provided by MicroPython for the keyboard
11 keybd = mpr121.MPR121(pyb.I2C(1, pyb.I2C.MASTER))
12 keybd.debounce(3,3)
13 for electr in range(4):
14 keybd.threshold(electr, 50, 30)
15
16 # Width and length of pulses for microstepping
17 pulseWidthUsecs = 1
18 betweenPulsesUsecs = 500
19
20 # Degrees per step calculation
21 upperDegreesToMove = 15
22 # Stepper motors move 1.8 degrees per full step
23 # In microstepping mode so 16 microsteps per step
24 # Motor shaft pulley has 20 teeth
25 # Upper arm pulley has 62 teeth
26 upperDegreesPerStep = (1.8/16)*(20/62)
27 upperStepsPerMove = upperDegreesToMove/upperDegreesPerStep
28
29 # Lower arm calculation as above
30 lowerDegreesToMove = 90
31 lowerDegreesPerStep = (1.8/16)*(20/62)
32 lowerStepsPerMove = lowerDegreesToMove/lowerDegreesPerStep
33
34 # Loop getting a key press and performing actions
35 while(True):
36 if (keybd.elec_voltage(1) < 220): # X Key
37 lowerArmDirn.value(0)
38 for i in range(lowerStepsPerMove):
39 lowerArmStep.value(1)
40 pyb.udelay(pulseWidthUsecs)
41 lowerArmStep.value(0)
42 pyb.udelay(betweenPulsesUsecs)
43 elif (keybd.elec_voltage(0) < 220): # Y Key
44 lowerArmDirn.value(1)
45 for i in range(lowerStepsPerMove):
46 lowerArmStep.value(1)
47 pyb.udelay(pulseWidthUsecs)
48 lowerArmStep.value(0)
49 pyb.udelay(betweenPulsesUsecs)

http://robdobson.com/2016/03/single-arm-robot/ 1/24/17, 9?44 AM

Page 5 of 21
 50 elif (keybd.elec_voltage(2) < 220): # B Key
51 upperArmDirn.value(0)
52 for i in range(upperStepsPerMove):
53 upperArmStep.value(1)
54 pyb.udelay(pulseWidthUsecs)
55 upperArmStep.value(0)
56 pyb.udelay(betweenPulsesUsecs)
57 elif (keybd.elec_voltage(3) < 220): # A Key
58 upperArmDirn.value(1)
59 for i in range(upperStepsPerMove):
60 upperArmStep.value(1)
61 pyb.udelay(pulseWidthUsecs)
62 upperArmStep.value(0)
63 pyb.udelay(betweenPulsesUsecs)
64 pyb.delay(1000)

Circle Intersections
The next thing to do was to work out how to move to a specified position in Cartesian coordinates.
I started to work out the geometry and quickly realised that I essentially had two intersecting
circles, one centred on the point I wanted to reach and the other centred on the origin of the robot
i.e. the position of its shoulder.

Searching the internet I found a collection of geometry

(http://paulbourke.net/geometry/circlesphere/) and then a convenient algorithm in Python
(https://gist.github.com/xaedes/974535e71009fa8f090e) copied below to perform the
calculations.

Python
1 from math import cos, sin, pi, sqrt, atan2, asin, acos
2 d2r = pi/180
3
4 def circle_intersection(circle1, circle2):
5 '''
6 @summary: calculates intersection points of two circles
7 @param circle1: tuple(x,y,radius)
8 @param circle2: tuple(x,y,radius)
9 @result: tuple of intersection points (which are (x,y) tuple)
10 '''
11 # return self.circle_intersection_sympy(circle1,circle2)
12 x1,y1,r1 = circle1
13 x2,y2,r2 = circle2
14 # http://stackoverflow.com/a/3349134/798588
15 dx,dy = x2-x1,y2-y1
16 d = sqrt(dx*dx+dy*dy)

http://robdobson.com/2016/03/single-arm-robot/ 1/24/17, 9?44 AM

Page 6 of 21
 17 if d > r1+r2:
18 print ("Circle intersection failed #1")
19 return None # no solutions, the circles are separate
20 if d < abs(r1-r2):
21 print ("Circle intersection failed #2")
22 return None # no solutions because one circle is contained within the other
23 if d == 0 and r1 == r2:
24 print ("Circle intersection failed #3")
25 return None # circles are coincident and there are an infinite number of solutions
26
27 a = (r1*r1-r2*r2+d*d)/(2*d)
28 h = sqrt(r1*r1-a*a)
29 xm = x1 + a*dx/d
30 ym = y1 + a*dy/d
31 xs1 = xm + h*dy/d
32 xs2 = xm - h*dy/d
33 ys1 = ym - h*dx/d
34 ys2 = ym + h*dx/d
35
36 return (xs1,ys1),(xs2,ys2)

Moving to an XY Position
The only challenge then was to perform a couple of simple trigonometric calculations (to calculate
the required angles at the two joints) and drive the stepper motors to the desired positions.

A significant aspect of this is that there should be no cumulative error. When a stepper motor
moves it can only move in increments of a little over 0.1 degrees (using microstepping as described
above). If a particular angle requires a movement of, say, 10.03 degrees then the number of steps
will be rounded to approximate this angle. If this rounding is performed repeatedly there will be
an increasing error in the angular position. To avoid this I remember the location of the elbow
and the number of steps each arm segment has performed since being at the origin position
which I assume is straight out initially. Then everything is calculated from this origin position.

A further piece of minor trickery is the section of code which actually moves the motors. This uses
a variant of Bresenhams Line Algorithm
(https://en.wikipedia.org/wiki/Bresenham%27s_line_algorithm) which handles a situation where
one variable increments on each loop and the other only periodically the great advantage of this
approach is that it can be done with integer arithmetic if required although this particular
MicroPython implementation has floating point.

http://robdobson.com/2016/03/single-arm-robot/ 1/24/17, 9?44 AM

Page 7 of 21
 Python
1 # Move to an x,y point
2 def moveTo(x,y):
3 global curLowerStepsFromZero, curUpperStepsFromZero
4 global curElbowX, curElbowY
5
6 p1, p2 = circle_intersection((x0,y0,L1), (x,y,L2))
7 # print("MoveTo x,y ", x, y, " intersection points ", p1, p2)
8
9 # Check the y values of each point - if only one is > 0 then choose that one
10 targetElbowPt = p1
11 if p1[1] >= 0 and p2[1] > 0:
12 # Both > 0 so choose point nearest to current position
13 delta1 = atan2(p1[0]-curElbowX, p1[1]-curElbowY)
14 delta2 = atan2(p2[0]-curElbowX, p2[1]-curElbowY)
15 if delta2 < delta1:
16 targetElbowPt = p2
17 elif p1[1] < 0 and p2[1] < 0:
18 print("Requested MoveTo x,y ", x, y, " intersection points ", p1,
19 print("Can't reach this point")
20 return False
21 elif p1[1] < 0:
22 targetElbowPt = p2
23 x1 = targetElbowPt[0]
24 y1 = targetElbowPt[1]
25 print("TargetElbowPt ", x1, y1)
26 # Calculate rotation angles
27 thetaUpper = atan2(x1-x0, y1-y0) / d2r
28 thetaLower = -atan2(x-x1, y-y1) / d2r
29 # Adjust lower rotation angle to compensate for mismatched gears - shoulder gear ha
30 # The result of this is that a 90 degree rotation of the upper arm results in a ((9
31 # So need to correct lower angle by 1/30th of upper angle
32 uncorrectedThetaLower = thetaLower
33 thetaLower -= thetaUpper / 30
34 print("ThetaUpper", thetaUpper, "ThetaLower", thetaLower, "(uncorrected thetaLower)
35 lowerSteps = int(thetaLower*lowerStepsPerDegree - curLowerStepsFromZero
36 upperSteps = int(thetaUpper*upperStepsPerDegree - curUpperStepsFromZero
37 print("Moving lower(total) ", lowerSteps, "(", curLowerStepsFromZero
38 # Check bounds
39 if (curUpperStepsFromZero + upperSteps > upperArmMaxAngle * upperStepsPerDegree
40 print("Upper arm movement out of bounds - angle would be ", curUpperStepsFromZe
41 return False
42 if (curLowerStepsFromZero + lowerSteps > lowerArmMaxAngle * lowerStepsPerDegree
43 print("Lower arm movement out of bounds - angle would be ", curLowerStepsFromZe
44 return False
45
46 lowerArmDirn.value(lowerSteps < 0)
47 upperArmDirn.value(upperSteps < 0)
48 accum = 0
49 lowerCount = 0
50 upperCount = 0
51 lowerAbsSteps = abs(lowerSteps)
52 upperAbsSteps = abs(upperSteps)
53 if lowerAbsSteps > 0 or upperAbsSteps > 0:
54 while(1):

http://robdobson.com/2016/03/single-arm-robot/ 1/24/17, 9?44 AM

Page 8 of 21
 55 if lowerAbsSteps > upperAbsSteps:
56 stepLower()
57 lowerCount += 1
58 accum += upperAbsSteps
59 if accum >= lowerAbsSteps:
60 stepUpper()
61 upperCount += 1
62 accum -= lowerAbsSteps
63 if lowerCount == lowerAbsSteps:
64 if upperCount < upperAbsSteps:
65 print("Lower > Upper - upper catching up by "
66 for i in range(upperAbsSteps-upperCount):
67 stepUpper()
68 break
69 else:
70 stepUpper()
71 upperCount += 1
72 accum+= lowerAbsSteps
73 if accum >= upperAbsSteps:
74 stepLower()
75 lowerCount += 1
76 accum -= upperAbsSteps
77 if upperCount == upperAbsSteps:
78 if lowerCount < lowerAbsSteps:
79 print("Upper > Lower - lower catching up by "
80 for i in range(lowerAbsSteps-lowerCount):
81 stepLower()
82 break
83 else:
84 print("Neither upper of lower arm moving")
85
86 curUpperStepsFromZero = curUpperStepsFromZero + upperSteps
87 curLowerStepsFromZero = curLowerStepsFromZero + lowerSteps

This is actually the final code with an additional fix which is described below.

Drawing a Straight Line

Next step was to attempt to draw a straight line. The code is simple now that we can move to an X,
Y position. The only thing we need to do is draw the line in small chunks because the MoveTo(x,y)
code doesnt guarantee that the point will be reached by moving in a straight line it simply moves
in the most efficient manner.

Python
1 def drawLine(x1, y1, x2, y2):
2 lineLen = sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2))
3 lineSegmentCount = int(lineLen)

http://robdobson.com/2016/03/single-arm-robot/ 1/24/17, 9?44 AM

Page 9 of 21
 4 x = x1
5 y = y1
6 xinc = (x2-x1)/lineSegmentCount
7 yinc = (y2-y1)/lineSegmentCount
8 for i in range(lineSegmentCount):
9 moveTo(x,y)
10 x += xinc
11 y += yinc
12 moveTo(x2,y2)

The result, unfortunately, wasnt so good as can be seen

(http://robdobson.com/wp-content/uploads/2016/03/20160331-Straight-Line-Attempt.png)

The line (marked with the red arrows) started ok it was drawing from top-left to bottom-right
and is reasonably straight for about 2/3 of its length. But the code then detected that it needed to
change from a forehand swipe to a backhand swipe and rotated the arms accordingly.
However, as can be seen, the continuation of the line is not where it should be the discontinuity
between the two lower red arrows.

http://robdobson.com/2016/03/single-arm-robot/ 1/24/17, 9?44 AM

Page 10 of 21
 A Flaw
The first test didnt show up an unexpected consequence of the changes I had made. But when I
tried the straight line test it immediately showed a problem.

Eventually I realised that when changing the number of teeth on the pulley (which transfers the
motion from the lower arm motor to the lower arm itself) I had unbalanced the two intermediate
pulleys in an unexpected way. I actually had considered that this change might affect the ratio on
the lower arm but had decided that the same intermediate pulley is used by both the motor drive
belt and lower arm pulley. So actually there is no such change as the two cancel each other out (i.e.
there is a 20:60 ratio on the first belt and a 60:62 ratio on the second so the overall effect is just
20:62 as it was originally). But what I hadnt thought about is that when the upper arm moves (and
the lower arm motor stays still) there is an effective turning of only the second stage of the drive
belt mechanism. So when the upper arm moves through 90 degrees (for instance) there is a
consequential movement of the lower arm by:

(90 * 62/60) 90 = 90 * 1 / 30 = 3 degrees

http://robdobson.com/2016/03/single-arm-robot/ 1/24/17, 9?44 AM

Page 11 of 21
 So in the end I added code to correct the angle calculation and tested with customised graph
paper as you can see above.

Sharethis:

Twitter (http://robdobson.com/2016/03/single-arm-robot/?share=twitter&nb=1)
Email (http://robdobson.com/2016/03/single-arm-robot/?share=email&nb=1)
LinkedIn (http://robdobson.com/2016/03/single-arm-robot/?share=linkedin&nb=1)
Google (http://robdobson.com/2016/03/single-arm-robot/?share=google-plus-1&nb=1)
Pinterest (http://robdobson.com/2016/03/single-arm-robot/?share=pinterest&nb=1)

http://robdobson.com/2016/03/single-arm-robot/ 1/24/17, 9?44 AM

Page 12 of 21
 Facebook (http://robdobson.com/2016/03/single-arm-robot/?share=facebook&nb=1)
Reddit (http://robdobson.com/2016/03/single-arm-robot/?share=reddit&nb=1)
Tumblr (http://robdobson.com/2016/03/single-arm-robot/?share=tumblr&nb=1)
Pocket (http://robdobson.com/2016/03/single-arm-robot/?share=pocket&nb=1)
Print (http://robdobson.com/2016/03/single-arm-robot/#print)

Comments
7

REPLY
(
(H TTP://ROBDOBSON.COM / 2 0 1 6 / 0 3 /SIN G L E-A RM - ROBOT/ ?R EP LYTOCOM = 3 7 1 1 4 # R ESP OND)

Swift
13 JANUARY 2017 AT 4:51 PM
(HTTP://ROBDOBSON.COM/2016/03/SINGLE-ARM-
ROBOT/#COMMENT-37114)

I am thinking of building a scara 3d printer. How many hours of design

and testing did it take you to get to this point?
Are there any regrets? Things you would have done differently?

Pingback: Play 2048 with a Robot Arm | robdobson.com

(http://robdobson.com/2016/05/play2048witharobotarm/)

http://robdobson.com/2016/03/single-arm-robot/ 1/24/17, 9?44 AM

Page 13 of 21
 REPLY
(
(H TTP://ROBDOBSON.COM / 2 0 1 6 / 0 3 /SIN G L E-A RM - ROBOT/ ?R EP LYTOCOM = 2 6 6 1 3 # R ESP OND)

ZhangZQ
2 APRIL 2016 AT 3:57 PM
(HTTP://ROBDOBSON.COM/2016/03/SINGLE-ARM-
ROBOT/#COMMENT-26613)

Hi, I also built such arm, and I also found the belt is very tight, so I
modified the gear from 62 to 60 teeth, And then I want to drive it using
Marlin, but it cant run the straight line. Did you try marlin?

R EP LY
(
(H TT P ://ROBDOBSON .COM / 2 0 1 6 / 0 3 / SIN G L E-A R M -ROBOT/ ?
R EP LYTOCOM = 2 7 3 6 1 # R ESPON D)

Javier
6 JUNE 2016 AT 10:53 AM
(HTTP://ROBDOBSON.COM/2016/03/SINGLE-ARM-
ROBOT/#COMMENT-27361)

Hi! I am also thinking on building a printer based on this

scara. Why it cant run an straight line? Does it make it
curved? There is an experimental Marlin that include
normal SCARA (not the morgan one) Do you have a
video or blog where I could see your work? Thank you in
advanced!

POST
AU THOR

http://robdobson.com/2016/03/single-arm-robot/ 1/24/17, 9?44 AM

Page 14 of 21
 R EP LY
(
(H TT P ://ROBDOBSON .COM / 2 0 1 6 / 0 3 / SIN G L E-A RM- ROBOT/ ?
REP LYTOCOM = 2 7 4 2 6 # R ESPOND)

rob
(http://robdobson.com)
24 JUNE 2016 AT 3:29 AM
(HTTP://ROBDOBSON.COM/2016/03/SINGLE-
ARM-ROBOT/#COMMENT-27426)

There is no problem drawing a straight

line if the maths is correct! The problem
Ive had is mainly due to testing and the
fact that the base of the arm is too small
and the vertical supports are not rigid
enough. Im still working on another
version but havent really got a solution to
the rigidity of the vertical posts.

REPLY
(
(H TTP://ROBDOBSON.COM / 2 0 1 6 / 0 3 /SIN G L E-A RM - ROBOT/ ?R EP LYTOCOM = 2 6 5 8 3 # R ESP OND)

Rupert
31 MARCH 2016 AT 7:29 PM
(HTTP://ROBDOBSON.COM/2016/03/SINGLE-ARM-
ROBOT/#COMMENT-26583)

Very cool looking forward to seeing what it can do!

http://robdobson.com/2016/03/single-arm-robot/ 1/24/17, 9?44 AM

Page 15 of 21
 POST
AUT HOR
R EP LY
(
(H TT P ://ROBDOBSON .COM / 2 0 1 6 / 0 3 / SIN G L E-A R M -ROBOT/ ?
R EP LYTOCOM = 2 6 5 8 7 # R ESPON D)

rob
31 MARCH 2016 AT 11:48 PM
(HTTP://ROBDOBSON.COM/2016/03/SINGLE-ARM-
ROBOT/#COMMENT-26587)

To be honest so am I. Its taken quite a bit of effort to

get this far mainly because I had to print pretty much
every part at least twice and redraw in the middle
which I wasnt really banking on.

Leave a Reply
Your email address will not be published. Required fields are marked *

Comment

Name*
)

http://robdobson.com/2016/03/single-arm-robot/ 1/24/17, 9?44 AM

Page 16 of 21
 Email*
*

Website
+

Submit

Notify me of follow-up comments by email.

Notify me of new posts by email.

, Search

Recent Posts
MK14 MEETS 7BOT (HTTP://ROBDOBSON.COM/2016/10/MK14-MEETS-7BOT/)

BOARD ANYONE? (HTTP://ROBDOBSON.COM/2016/08/BOARD-ANYONE/)

A LITTLE LOGGER (HTTP://ROBDOBSON.COM/2016/07/A-LITTLE-LOGGER/)

PLAY 2048 WITH A ROBOT ARM

(HTTP://ROBDOBSON.COM/2016/05/PLAY2048WITHAROBOTARM/)

NON-VESTING SHARE OPTIONS (HTTP://ROBDOBSON.COM/2016/04/NON-

VESTING-SHARE-OPTIONS/)

http://robdobson.com/2016/03/single-arm-robot/ 1/24/17, 9?44 AM

Page 17 of 21
 Recent Comments
SWIFT ON SINGLE-ARM ROBOT (HTTP://ROBDOBSON.COM/2016/03/SINGLE-
ARM-ROBOT/COMMENT-PAGE-1/#COMMENT-37114)

JOHN ON NON-VESTING SHARE OPTIONS

(HTTP://ROBDOBSON.COM/2016/04/NON-VESTING-SHARE-
OPTIONS/COMMENT-PAGE-1/#COMMENT-34841)

GW ON NON-VESTING SHARE OPTIONS

(HTTP://ROBDOBSON.COM/2016/04/NON-VESTING-SHARE-
OPTIONS/COMMENT-PAGE-1/#COMMENT-34826)

BEWERTUNG HAUSRATVERSICHERUNG HUK (HTTP://HAUSRATVERSICHERUNG.TECH/BEWERTUNG-

HAUSRATVERSICHERUNG-HUK.HTML)

ON A LITTLE LOGGER (HTTP://ROBDOBSON.COM/2016/07/A-LITTLE-

LOGGER/COMMENT-PAGE-1/#COMMENT-34373)

HTTP://WWW./ (HTTP://WWW./)

ON NON-VESTING SHARE OPTIONS (HTTP://ROBDOBSON.COM/2016/04/NON-

VESTING-SHARE-OPTIONS/COMMENT-PAGE-1/#COMMENT-34260)

Archives
OCTOBER 2016 (HTTP://ROBDOBSON.COM/2016/10/)

AUGUST 2016 (HTTP://ROBDOBSON.COM/2016/08/)

JULY 2016 (HTTP://ROBDOBSON.COM/2016/07/)

MAY 2016 (HTTP://ROBDOBSON.COM/2016/05/)

APRIL 2016 (HTTP://ROBDOBSON.COM/2016/04/)

MARCH 2016 (HTTP://ROBDOBSON.COM/2016/03/)

http://robdobson.com/2016/03/single-arm-robot/ 1/24/17, 9?44 AM

Page 18 of 21
 SEPTEMBER 2015 (HTTP://ROBDOBSON.COM/2015/09/)

AUGUST 2015 (HTTP://ROBDOBSON.COM/2015/08/)

JULY 2015 (HTTP://ROBDOBSON.COM/2015/07/)

MAY 2015 (HTTP://ROBDOBSON.COM/2015/05/)

MARCH 2015 (HTTP://ROBDOBSON.COM/2015/03/)

FEBRUARY 2015 (HTTP://ROBDOBSON.COM/2015/02/)

SEPTEMBER 2014 (HTTP://ROBDOBSON.COM/2014/09/)

AUGUST 2014 (HTTP://ROBDOBSON.COM/2014/08/)

JUNE 2014 (HTTP://ROBDOBSON.COM/2014/06/)

APRIL 2014 (HTTP://ROBDOBSON.COM/2014/04/)

JANUARY 2014 (HTTP://ROBDOBSON.COM/2014/01/)

NOVEMBER 2013 (HTTP://ROBDOBSON.COM/2013/11/)

OCTOBER 2013 (HTTP://ROBDOBSON.COM/2013/10/)

JANUARY 2012 (HTTP://ROBDOBSON.COM/2012/01/)

DECEMBER 2011 (HTTP://ROBDOBSON.COM/2011/12/)

MARCH 2011 (HTTP://ROBDOBSON.COM/2011/03/)

OCTOBER 2010 (HTTP://ROBDOBSON.COM/2010/10/)

Categories

http://robdobson.com/2016/03/single-arm-robot/ 1/24/17, 9?44 AM

Page 19 of 21
 COMPANY LINKS (HTTP://ROBDOBSON.COM/CATEGORY/COMPANY-LINKS/)

FRONT PAGE (HTTP://ROBDOBSON.COM/CATEGORY/FRONT-PAGE/)

GETITMADE (HTTP://ROBDOBSON.COM/CATEGORY/GETITMADE/)

HACKING AND TINKERING (HTTP://ROBDOBSON.COM/CATEGORY/HACKING-AND-

TINKERING/)

HOME AUTOMATION (HTTP://ROBDOBSON.COM/CATEGORY/HOME-

AUTOMATION/)

OTHER PURSUITS (HTTP://ROBDOBSON.COM/CATEGORY/OTHER-PURSUITS/)

STARTUPS (HTTP://ROBDOBSON.COM/CATEGORY/STARTUPS/)

Meta
LOG IN (HTTP://ROBDOBSON.COM/WP-LOGIN.PHP)

ENTRIES RSS (REALLY SIMPLE SYNDICATION) (HTTP://ROBDOBSON.COM/FEED/)

COMMENTS RSS (REALLY SIMPLE SYNDICATION)

(HTTP://ROBDOBSON.COM/COMMENTS/FEED/)

WORDPRESS.ORG (HTTPS://WORDPRESS.ORG/)

http://robdobson.com/2016/03/single-arm-robot/ 1/24/17, 9?44 AM

Page 20 of 21
 !
(https://twitter.com/robdobsn)
"
(https://www.linkedin.com/in/robdobsn)
C O M PA N Y I N V O LV E M E N T S ( H T T P : // R O B D O B S O N . C O M / C O M PA N Y- I N V O LV E M E N T S / )
L I N K E D I N ( H T T P S : // W W W. L I N K E D I N . C O M / I N / R O B D O B S N )
T W I T T E R ( H T T P : // T W I T T E R . C O M / R O B D O B S N )
H A C K I N G A N D T I N K E R I N G ( H T T P : // R O B D O B S O N . C O M / C AT E G O R Y/ H A C K I N G - A N D -
TINKERING/)
H O M E A U TO M AT I O N ( H T T P : // R O B D O B S O N . C O M / C AT E G O R Y/ H O M E - A U TO M AT I O N / )
A B O U T ( H T T P : // R O B D O B S O N . C O M /A B O U T/ )

http://robdobson.com/2016/03/single-arm-robot/ 1/24/17, 9?44 AM

Page 21 of 21