New Website

Hey All,

Well the LittleArm is being formalized a little bit. That means improvements. One of those improvements is a new website.

Here is the new LittleArm Website. On it you will find all the same resources as on this blog, but they will be better organized. Check out the new site and let us now what you think.

Design: New Wrist

We have designed a new wrist for the LittleArm. This can only be used in place of the actuated gripper. Therefore the end effectors that can be used are currently the hook and clamp for markers.

This wrist does allow for better implementation of drawing programs since it is now possible to keep the pen vertical.

STL files for the wrist can be downloaded here.

Design: Gripper Attachment Dimensions

For all of those out there that are making their own LittleArm and want to create a custom gripper, here are the dimensions of the adapter slot and gripper fitting.

Tutorial: Build the LittleArm

Here is a tutorial outlining the different steps taken to assembly the LittleArm robot kit.

Testing Teaching Pendant - Dancing Robot

We are working to create a teaching pendant for the LittleArm 3D printed robot. While we were doing some tests music was playing so we rolled with it. Enjoy

We Just Launched on Kickstarter

We have been working to turn the 3D printed robot into a kit. We are almost there.

We have launched a Kickstarter to get the funds needed to start producing the LittleArm in greater quantity. Please check out the LittleArm Campaign and be one of the first to get the kit.

But of course always feel free to download the parts and code to make your own.

Installing and Running Python on Windows

For those that use Windows.

In order to run the python programs on this website for the LittleArm (3D Printed Robot Arm) you will need Python installed. And if you want to use it from the command line you will need to add it to your environmental variables

Here is a tutorial on how to install Python and then run it from the command line. 

For those that do not like to read, here is a video of the process.

Instead of running our programs from the command line, you may also simple start up Python IDLE and then open and run the python programs from this website. That is a more intuitive and graphical method.

Here is our own video on installing python and running the programs in IDLE

Tutorial: Training the Robot Arm using the Python Gui

We have had the capability to train the robot for a while now. Here is the code used in this tutorial.

The interface is already pretty intuitive, but some of the application may not be clear. Soon we will make a video of how to launch the GUI and get it working on windows.

In the meantime have fun training the robot. And please share what you make it do on the forum

There are two tutorials, the long version and the short. Use the one you need.

Long Version

Short Version

Demo: Most Useless Machine

We are working on putting together a bunch of demos for tutorials and videos. This is one of the first. It is our take of the "World's Most Useless Machine."

We used the training function to get the motion down. In the future we may create an Vision system that can detect objects that the robot can just move.

Graphical Arduino Programming

Hey Everyone,

We have built a decent foundation of code for everyone to start making some cool programs. But that code is still standard computer code (C and Python). We would like to make easier for those who are new to programming to work with the 3D Printed Arm.

Here is a Block-Based Graphical Arduino Programmer, Blockly, and it is online so you can use it anywhere to program Arduino. We will create a tutorial very soon of how to program a set of sequences with this program.

We will also convert several of our basic Arduino Programs to Blockly as soon as we can. And we are working on getting a web interface up so that you don't have to go through the hassle of setting up python on your computer.

Another alternative to Blockly is BitBloq


Parallel Execution of Joint Motions

Normally when you make a robot, you don't want it to move one joint at a time. Usually you want something more fluid where several joints are moving in tandem.

While it is impossible to have parallel execution on the arduino, the illusion of parallel execution can be achieved.

It is done by moving each joint only a few degrees and then moving the next joint a few degrees. Since the delays between the movements are milliseconds it appears as if all the joints are moving at once.

This code was tested using the Training Program created in the last post.  The user control the arm to some position they want it to be at and then records that position. Then when there are several positions the arm will move directly to each point.

For those familiar with engineering, what we have created is a very basic PD controller.

What is great about this parallel movement is that while before when we did training we may have had to record single joint movements to ensure that the arm didn't collide with the table. Now that is not as much of a worry since all the joints can move to their desired positions simultaneously.

Code for this post for Parallel Joint Movement

//Primary Function for Simultaneous Servo Motion
int servoParallelControl (int thePos, Servo theServo ){
    int startPos =;        //read the current pos
    int newPos = startPos;
    int theSpeed = 9;
    //define where the pos is with respect to the command
    // if the current position is less that the actual move up
    if (startPos < (thePos-5)){
       newPos = newPos + 1;
       return 0;
   else if (newPos > (thePos + 5)){
      newPos = newPos - 1;
      return 0;
    else {
        return 1;

Training the Robot: Record a Motion Sequence and Play It Back

Record Sequence and Playback Code

A robot is not very useful unless a person can work with it easily. While it is not difficult to put in commands for where the servos should be positioned, it is much easier if you can direct a robot to where it needs to be and have it remember that action.

That is what this program is for. Using the GUI one can move the 3D printed robot arm through a series of motions, recording each step, and then have the robot repeat the seqence. It is a great piece of software for just creating quick demos. Or for kids to learn how programming works sequentially.

The next step will be to modify to the arduino code so that is changes all of the servo positions seemingly simultaneously. Right now it moved the shoulder then the elbow. This is a little slow and un-elegant. The next iteration will have them all moving at once.

See the video below to watch how to train the robot.

Demo: Pick and Place

Here is a very simple example of using the servo control function that was created early just to have the robot perform a set of preprogrammed tasks.

In order to get the positions I used the gui program to take it through the sequence. I recorded the positions and then entered the sequence into the arduino code.

In the future I will add a recording feature to the python code so that the user can use the gui to move the arm through positions and then just have it repeat the motions automatically.

Here is the Pick and Place code

For any other resources visit the Project Links Page

If you don't want the file you can copy and paste the code below

#include <Servo.h>  //arduino library
#include <math.h>   //standard c library

#define PI 3.141

Wiring Diagram: Arduino 3DOF Arm

Here is a basic wiring diagram for the 3DOF arduino robot arm. All the parts for the diagram can be found on the Project Links Page

Testing 3D Printed Gripper

We are trying out a few different 3d printed gripper designs.

For this one, each finger has a gear printed at the joint so that when 1 moves the other does also. This can be tougher to print but it is a nice mechanism.

The print went bad about 3/4 of the way through, but we were able to get a proof-of-concept test finished.

We are also making a rigid gripper that can hold a Sharpie, and one that is just a small hook.

The servo-actuated finger of the 3D printed gripper

GUI Demo: Real Time Video of Python Gui

This is a demonstration of using the python GUI implemented in Tkinter to control the servos of the 3D printed robot arm.

Python Gui V2: Real Time Control of the Arm

The code below gives real time control of the arm using scale bars in a python gui. There is a slight lag in control due to the speed of the USB connection but it has proven to reliable.

Arduino Code

#include <Servo.h>  //arduino library
#include <math.h>   //standard c library

#define PI 3.141

Servo baseServo;
Servo shoulderServo;
Servo elbowServo;
Servo gripperServo;

int command;

struct jointAngle{
  int base;
  int shoulder;
  int elbow;

Python + Arduino: GUI Control through Serial

I have created a basic gui program that allows me to move the arm to particular positions by controlling the angle of the servos. Scale bars created in python using Tkinter define the angle of the servo. Those angles are then sent to the arduino which uses the servo control function created earlier in the project to move the servos to the new desired position. For the moment the "move arm" button must be pressed to send a new value. It is very simple to have the arm follow the trackbar position live and that will come next, but for the moment this piecemeal layout makes the operations clearer.

Python Gui created in Tkinter

Below is the arduino code. 

#include <Servo.h>  //arduino library
#include <math.h>   //standard c library

#define PI 3.141

Servo baseServo;
Servo shoulderServo;
Servo wristServo;

int command;

struct jointAngle{
  int base;
  int shoulder;
  int elbow;

struct jointAngle desiredAngle; //desired angles of the servos

//+++++++++++++++FUNCTION DECLARATIONS+++++++++++++++++++++++++++

void servoControl (int thePos, int theSpeed, Servo theServo);


Arduino Code: Kinematic Function for Servo Arm

Here is the arduino function that determines the location of the tip of the robot arm in 3D cartesian space using kinematics.

Note: While this function was designed to be used with the 3D printed microservo arm being built in this project. You may change the physical parameters of the arm to match those of any servo arm and the code will work perfectly.

The code below has the structure definition needed to setup the function and then the function itself. Soon an example program will be posted with this function implemented.

struct xyzPos{                //a struct to hold multple returned arguments for the 3D position
  float x;
  float y;
  float z;

struct xyzPos currentPos;     //current location of tip of arm
struct xyzPos desiredPos;     //desired location of tip of arm

//+++++++++++++++FUNCTION DECLARATIONS+++++++++++++++++++++++++++

void servoControl (int thePos, int theSpeed, Servo theServo);
struct xyzPos kinematics(float baseAng, float shoulderAng, float wristAng);



struct xyzPos kinematics(float baseAng, float shoulderAng, float wristAng){
    // this function takes the servo angles as input and computes the locaiton of the tip of the arm in 3D space
    Serial.println("in kinematics");
    struct xyzPos POS;

    // the physical parameters of the arm.
    float baseHeight   = 3;
    float upperArm     = 5;
    float foreArm      = 0;       // left at 0 since current arm does not have wriist
    double gripper     = .5;

    //convert servo angles to radians for trig functions
    baseAng = (baseAng * PI /180);
    shoulderAng = (shoulderAng * PI /180);
    wristAng = (wristAng * PI /180);

    // kinematic equations of the robot arm. These equations describe where it is based on the angle of the arm. 
    POS.x = (upperArm*cos(baseAng)*cos(shoulderAng))   +    (cos(baseAng)*(foreArm*cos(shoulderAng+wristAng))   );
    POS.y = baseHeight + (upperArm*sin(shoulderAng)) + (foreArm*sin(shoulderAng+wristAng)) ;
    POS.z = (upperArm *(-sin(baseAng))*(cos(shoulderAng))) - (sin(baseAng) * (      (foreArm*cos(shoulderAng+wristAng))          ));

    //Prints used for error checking if necessary
    Serial.print("xpos = ");
    Serial.print("ypos = ");
    Serial.print("zpos = ");
    Serial.println(POS.z); */
    Serial.println ("done with function");
    return POS; //return the #D position of the arm

If you would like to learn more about using structures in c here are some explanations.

Arduino Code: Basic Servo Control Function

Here is a first iteration of a function that can be used to control the position of a servo. The user may user the arduino serial interface or some other serial program to send a position to the arduino and have the servo move to that position.

The code is below

#include <Servo.h> 

Servo baseServo;  
Servo shoulderServo;  
Servo wristServo; 

int command;
int pos = 0;    // variable to store the servo position 

//+++++++++++++++FUNCTION DECLARATIONS++++++++++++++++++++++

void servoControl (int thePos, int theSpeed, Servo theServo);


void setup() 

  baseServo.attach(9);  // attaches the servo on pin 9 to the servo object 

void loop() 

  if (Serial.available()){
    command = Serial.parseInt();  
    servoControl(command, 15, baseServo);
    servoControl(command, 15, shoulderServo);
    servoControl(command, 15, wristServo);    


//++++++++++++FUNCTION DEFINITIONS+++++++++++++++++++++++
void servoControl (int thePos, int theSpeed, Servo theServo){
  Serial.println("in function");
  //read the current pos
  int startPos =;
  int newPos = startPos;
  //define where the pos is with respect to the command
  // if the current position is less that the actual move up
  if (startPos < thePos){
        while (newPos < (thePos - 5)){
          newPos = newPos + 5;

       while (newPos > (thePos + 5)){
         newPos = newPos - 5;

Design Specs: Goals of the Arm

This is the list of goals and design specifications that will be met in the 3D printed arm part of this project. There will be two phases on the mechanical design. A very simple low cost arm and a more capable but expensive arm

Low Cost Arm
  1. Aside from screws all structural components must be 3-D printed (using makerbot)
  2. Excluding the microcontroller, component cost must be <$25
  3. Arm must lift 1.5 oz at maximum extension
  4. May only use a single type of servo
  5. Controlled from keyboard (no more than 6 keys)
  6. <5 3D printed parts
Higher Cost Arm
  1. Modular gripper that can hold writing utensil
  2. Excluding the microcontroller, component cost must be <$40
  3. May only use a single type of servo
  4. Controlled by mouse
  5. <8 3D printed parts
Future Expansions
  1. Trainer Pendant Arm
  2. Sense and Follow
  3. Implement with webcam to collect objects and draw picture
  4. More grippers

Arm Demo: Prototype Videos

An initial prototype for the arm was completed recently. Here are a couple of videos.

Operated from Keyboard

Servo Sequence