The LittleArm is kit ideally suited to STEM classrooms. Every component of it can lend itself to a lesson in some part of the STEM industry. Whether is be electronics, CAD, 3D printing, or advanced robotics. The LittleArm is useful from the beginner all the way to the college student. We are going to give a you a few ideas of how that is possible in this post.

The minimum unsupervised age for the LittleArm is about 10 years old. This is due to the need for a certain level of manual dexterity to put it together, such as the six screws in the shoulder, elbow, and gripper. If an adult is present to help kids put those fasteners in, then the minimum age can be as low as 6 years old.

Once the arm is built, no programming is required to teach the arm to perform work. Students can simply move the arm through a set of motions and record them.

​A viable assignment would be for the students to combine their arms into an assembly line. Then each students teaches his/her LittleArm to add some piece to the "product." This assignment gives students a general outline of how robots work, and the real world applications of them.

Learning to program can be a daunting task. The understanding of computer languages and syntax is not a shallow learning curve.

There are several graphical programming languages out there which greatly simplify programming by eliminating the need to understand the syntax of programming (where to put the semi-colon), and instead focus on the function (how a loop works).

The two most common graphical languages are Scratch and Blockly. Since the LittleArm is based on the Arduino it can be reprogrammed using Blockly. And we have placed videos on the Tutorials page to get you started.

 If your students are at a level where they understand the concepts of programming and are ready to start writing code from scratch, with no special tools to facilitate the code, then the LittleArm is still viable. 

Again, since it is based on the Arduino it has all the support of a world-wide programming community. There are few questions (if any) that have not been answered about programming the Arduino. Arduino code is also simplified a bit to facilitate learning even more. Instead of having to write an entire piece of code to control a servo, a programmer only has to write Servo(40) and that will drive the servo to an angle of 40 degrees.

The LittleArm is also an ideal programming platform because it creates real-world feedback, not just a feed of numbers. Kids can see how those numbers relate directly to a machine in life.

If you are a teacher at the high school and even college level, the LittleArm is a viable platform for teaching advanced robotics. Most robotics programs prefer arms as opposed to mobile robots because arms are more flexible. 

Due to its baseline software the LittleArm has the capability to interface with computers to run computationally intensive vision programs to search and grab objects. Also, since all of its measurements or highly defined and it uses servos, kinematic programs can be implemented on the arm.

Quite literally, at upper levels the LittleArm is an excellent platform for testing software in the real world without the high cost of hardware. (We have even done experiments in deep learning with the arm)

The LittleArm was designed to be 3D printed. Students can learn how the process works by printing their own LittleArm.

But design the the true learning experience. STEM students can gain a lot from learning to use programs like Autodesk, or sketchup, and then having their designs made on the printer. We recommend that teacher have the students use our primary files for creating the main components of the arm. But the gripper was designed to be interchangable. Students can design their own tools and grippers to place on the end of the LittleArm. This creates a manageable assignment, that students can see the fruit of.

Teachers can implement a design competition for the best gripper. Several objects could be used. Students can be judged on accuracy of their gripper in moving objects. How many of the objects they can pick up, and how fast they can do it.

The LittleArm comes with a miniature breadboard to go with the Arduino. The Arduino again provides the tutorial and resource base to learn how microprocessors and basic circuits work. The breadboard allows students to actually experiment.

A viable class would be to have students can add sensors to the arm which stop the arm when the sensor is tripped, just as real industrial arms do. In order to achieve this they would have to create an appropriate circuit to send the signal from the sensor the Arduino and then write the code to have the arduino work with that signal.

They could also create little controller boards which control the arm in place of the desktop app. We have also created a training pendant with all the designs and code, which students can build from scratch. (video below)

So there are a few ideas of how to teach with the LittleArm. We hope they help.

A few of you may have seen this video we made several months ago. In it the LittleArm arduino robot is dancing to a Roy Orbison son. It is able to dance because it is being controlled by a device called a Waldo.

A Waldo is basically a motion capture device. We use potentiometers to control the the position of the servos on the LittleArm.

When we posted the video we posted the code and the initial designs for the 3D printed parts of the Waldo on the Downloads page. Today we are posting the the electrical diagram. 

We apologize that it has taken so long. But we have been pretty swamped moving LittleArms out the doors to create much content.

But better late than never. Here is the wiring diagram to build your own motion capture Waldo training pendant for the LittleArm. (Just a Note: We have also created a recording piece of software that needs another button and conects the arm and the Waldo to a computer to record the motion. That post will be coming in a few days.)

And here is the code that goes with the diagram.

​// training program with gripper button working.

#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;
};

int desiredGrip = 30;

int basePotPin = A0;
int shoulderPotPin = A1;
int elbowPotPin = A2; 

int desiredDelay = 3;

int potValHolder1;
int potValHolder2;
int potValHolder3;

int recordPin = 2;
int gripPin = 3;

bool gripped = 1;

bool holder = 1;

struct jointAngle desiredAngle; //desired angles of the servos

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

int servoParallelControl (int thePos, Servo theServo );
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

void setup()
{ 
  Serial.begin(9600);
  baseServo.attach(9);        // attaches the servo on pin 9 to the servo object 
  shoulderServo.attach(10);
  elbowServo.attach(11);
  gripperServo.attach(6);
  
  Serial.setTimeout(50);      //ensures the the arduino does not read serial for too long
  Serial.println("started");
  baseServo.write(90);        //intial positions of servos
  shoulderServo.write(150);
  elbowServo.write(110);


  pinMode(gripPin, INPUT);
  pinMode(recordPin, INPUT);
  
} 

//primary arduino loop
void loop() 
{ 
    potValHolder1 = analogRead(basePotPin);
    if (potValHolder1 < 500){
        desiredAngle.base = map(potValHolder1, 0, 500, 175, 5);
    }
    
    potValHolder2 = analogRead(shoulderPotPin);
    if (potValHolder2 > 500){
       desiredAngle.shoulder = map(potValHolder2, 501, 1023, 175, 5);
    }
    
    potValHolder3 = analogRead(elbowPotPin);
    if (potValHolder3 < 500){
       desiredAngle.elbow = map(potValHolder3, 0, 500, 175, 5);
    }

   // holder = digitalRead(gripPin);


// read the gripper button to define position. 
// when the button is pressed the gripper changes positions
    if ((digitalRead(gripPin) ==HIGH) ){
      gripped = !gripped;    

      if (gripped == 1){
        desiredGrip = 3;
      }
      if (gripped == 0){
        desiredGrip = 75;
      }
      
    }

  int status1 = 0;
  int status2 = 0;
  int status3 = 0;
  int status4 = 0;
  int done = 0 ; 
  
  while( done == 0){  
    //move the servo to the desired position
    status1 = servoParallelControl(desiredAngle.base, baseServo, desiredDelay);
    status2 = servoParallelControl(desiredAngle.shoulder,  shoulderServo, desiredDelay);
    status3 = servoParallelControl(desiredAngle.elbow, elbowServo, desiredDelay);      
    status4 = servoParallelControl(desiredGrip, gripperServo, desiredDelay);  
    
    if (status1 == 1 & status2 == 1 & status3 == 1 & status4 == 1){
      done = 1;
      
    }
        
  }// end of while
}

//++++++++++++++++++++++++++++++FUNCTION DEFITNITIONS++++++++++++++++++++++++++++++++++++++++++

int servoParallelControl (int thePos, Servo theServo, int theSpeed ){
  
    int startPos = theServo.read();        //read the current pos
    int newPos = startPos;
    //int theSpeed = speed;
    
    //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;
       theServo.write(newPos);
       delay(theSpeed);
       return 0;
           
    }
  
   else if (newPos > (thePos + 5)){
  
      newPos = newPos - 1;
      theServo.write(newPos);
      delay(theSpeed);
      return 0;
          
    }  
    
    else {
        return 1;
    }  
    
}