Computer Controlled Cutting Electronics Production 3D Scanning and Printing Electronics Design Computer-Controlled Machining Embedded Programming Molding and Casting Input Devices Output Devices Networking and Communication Interface and Application Programming Mechanical & Machine Design

Group Assignment: Mechanical & Machine Design

The goal for this week's assignment was to design a machine that includes mechanism, actuation and automation. Bulid the mechanical parts and operate it manually.


We've had some ideas for this assignment: Juicer, Fab-Tour Bot, Robotic Arm. For each of them we created a concept before we decided what to do.

Juicer: Requirements

  • Provides orange juice from oranges.
  • Can make smoothies ( at least 2 ingredients)
  • Ice can be dded to the mix.
  • Can be remotely controlled.
  • Can self-clean.
  • Has to be food safe.
  • (additionally if possible) places a cup.
  • (additionally if possible) possibility to add alcohol.
  • Fab-Tour Bot: Requirements

  • Servo or stepper?
  • manual or automatic control.
  • Actuate two degrees and freedom.
  • (additionally if possible) Robot answers questions about machines.
  • Robotic Arm: Requirements

  • 3 degrees freedom at least.
  • Modular grabbing system.
  • Can hold up to 100 grams.
  • Remote of control and/or control with joystick.
  • Kill button.
  • (additionally if possible) sensor for safety.
  • (additionally if possible) ways to generate GCODE.
  • Pick & Place simulation.
  • After spending weeks on deciding what to make ranging from an Juicer to a Fab-tour Bot, we finally decided on making the Robotic Arm.

    Robotic Arm: Technical Concept

  • 3 steppers/servos.
  • Self-designed microcontroller board.
  • A way to center the arm.
  • Power supply.
  • Sensors (?)
  • Pick & Place mechanism.
  • Mechanical Design: Planetary Gears

    Alessandra Crotty worked on the bottom part of the robotic arm. For the mechanical part she developed a planetary gearset to distribute the weight among several gears. Any planetary gearset has three main components:

  • The sun gear
  • The planet gears and the planet gears carrier
  • The ring gear
  • Each of these three components can be the input, the output or can be held stationary. Choosing which piece plays which role determines the gear ratio for the gearset.

    In this case, the planet wheels and the planet carrier are the ones that are kept stationary, while the ring gear is the one that moves. Planetary gears are often used when space and weight are an issue, but a large amount of speed reduction and torque are needed.

    Mechanical Design: Grabbing System

    Hakan Zayin created grabbing system of the arm. He was looking for different ways to grab objects. After a while he decided to use a servo motor to move a gear that moves a linear gear to open and close the hand.

    Machine Design: Arm Design

    Markus Fleischer devoted himself to the design of the shape of the arm, because of the experiance he has as a 3d-artist. He designed everything in Blender.

    At some point it turned out that parts of the arm where way too heavy, which stopped the arm from moving, so Florian Schaefer exchange each connection-element of the arm for a much smaller version. All adapters have a length of 4cm and are of the same diameter as the base elements of the original connectors.

    Machine Design: Modular Joints

    The joints are designed to make the whole arm modular, so every 'bone' can easily be swapped out for another one. This actually helped us in the long run, but more on that later.

    TThis is what it looks like put together.

    Hakan Zayin created the upper joint that holds the stepper motor. Because we wanted the arm to be light so it could move easily, he chose a honeycomb pattern to save weight.

    Machine Design: Bottom Part

    Alessandra Crotty designed the bottom part, which contains the planetary gears.

    Alessandra Crotty also worked together with Christian Schendera, a student who volunteered to attend the FabAcademy. He designed the joint to attach the arm to the base.

    The stepper motors we use to turn the joints are only based on a torque of 28 nanometers. We didn't want to increase the size too much. So we wanted to increase the power without increasing the weight on the arm with a stronger but heavier motor.What we have decided is a mechanism that increases torque and reduces speed. We came from a small 18mm diameter gear to a larger 64mm diameter gear and hoped it would be strong enough. In the middle of the two large gears we insert a 14mm ball bearing running on an 8mm thread.In order to hold the shaft and also the motors, I built two houses, which are individually designed and fit perfectly to the specific parts. On the upper part there is space for the same ball bearings, which are inserted into the gears.

    Microcontroller Board

    Alessandra Crotty also made the microcontroller board for this week's assignment. She decided to use a Atmega1284, since it has more pins and we are going to use 5 stepper motors and one servo motor.


    Alessandra Crotty worked on a code that rotates the bottom part of the robotic arm as soon as you enter a value into the serial communication.

    // defines pins numbers
    const int stepPin = 3; 
    const int dirPin = 4; 
    // Stepper Travel Variables
    String incomingData;   // for incoming serial data
    int val = 0;	// parse the incoming data to an int 
    int enable = 13;
    void setup() {
      // Sets the two pins as Outputs
      digitalWrite(enable,HIGH);	//disable the motors
      digitalWrite(dirPin,HIGH);	//rotates the motor clockwise
      Serial.begin(9600);  // Start the Serial monitor with speed of 9600 Bauds
    // Print out Instructions on the Serial Monitor at Start
      Serial.print("Enter Move Values Now: ");
    void loop() {
     if (Serial.available() > 0) {
                    incomingData = Serial.readString();		
                    val= incomingData.toInt();	
                    digitalWrite(enable,LOW);	//enables the motor
      if (val > 0 ) {
      // Makes 800 pulses for making one full cycle rotation
      for(int x = 0; x < val ; x++) {
       val = 0;

    In the meantime Florian Schaefer worked on a code to address all motors.The software is controlled over the serial monitor and can be used to learn about the way the robotic arm makes it's movements. Later the target values could be pre-defined or even calculated on the go. The only thing really needed is a reliable zero position, otherwise movements can not be reused. Complex tasks could be fulfilled by chaining multiple calls to moveTo. A problem with this code is that it's still moving step by step and has no concept of acceleration and deceleration.

    #include <Stepper.h>
    Stepper motors[] = {
      // The first value is the number of steps the motor needs for one revolution, adjust it accordingly
      Stepper (200, PA0, PA1, PA2, PA3), // Base
      Stepper (200, PB0, PB1, PB2, PB3), // Joint one, just double the wires to send the signal to both motors
      Stepper (200, PC0, PC1, PC2, PC3) // Joint two
    // This can be any position of the arm but the movements will be relative to it
    int steps[] = {0, 0, 0};
    // fin[] and finCount have to be reset before a new target 
    boolean fin[] = {false, false, false};
    int finCount = 0;
    // These are used to hold the serial input
    int a = 0; int b = 0; int c = 0;
    void setup() 
    void loop() {
      Serial.write("Enter target position");
      a = Serial.read();
      Serial.write("Joint 1");
      b = Serial.read();
      Serial.write("Joint 2");
      c = Serial.read();
    void moveTo(int baseTarget, int jointOneTarget, int jointTwoTarget){
      while(finCount < 3){ // When all three have finished we are done
            //Move each motor one step towards the target positiont
            moveMotorOneStep(0, baseTarget); 
            moveMotorOneStep(1, jointOneTarget);
            moveMotorOneStep(2, jointTwoTarget);
    void moveMotorOneStep(int motor, int target){
        if(steps[motor] < target){ // We need to move forward
                else if(steps[motor] > target){ // We need to move back
                }else if(fin[motor] == false) { // we are in the target position
                  fin[motor] = true;

    Download Files


    Machine Bilding