Wally - The 3D Printer

Mechanical Design

So for this week is concerned, its all about Group Asssignment to develop a machine that makes (the machine). It was quite a new experience for all of us to work together in a group to develop something. Initially we planned some meetings to come up with an idea of a machine that we can make. Finally after some due delibration we decided to make a special type of 3D Printer generally called "Wally".

Wally is a wall bot where everything is mounted on the wall. Wally is a variant of reprap 3D printers which belong to Selective Compliance Assembly Robot Arm (SCARA) family. The idea was to make Wally as simple and low cost as possible, and use much less plastic and bearing than other does, but has faster speed and better resolution.

The printed parts take almost 1kg of PLA and 40-45 hours to print a complete set. Nicholas Seward recommends PLA printed at a 0.3mm layer height and 15% infill with 3 perimeters.

RepRap Community is working for the portable and replicable 3D printers. RepRap is humanity's first general-purpose self-replicating manufacturing machine. Since many parts of RepRap are made from plastic and RepRap prints those parts, RepRap self-replicates by making a kit of itself - a kit that anyone can assemble given time and materials.

Details about the concept:

• Built off a rigid back board. The board can have ribs attached to make it more rigid. The material is TBD based on prototype needs.
• Wally could be designed to fold fairly flat for storage or portability. Think suitcase with a handle on the side. Legs could fold out to make it free standing, or it could be attached to a wall.
• The design can be scaled. Perhaps a 12" backboard width at the small end. That might give more than a 6" cube build volume. A 15" backboard width might give something on the order of 10" Diameter, or an 8" square, or a 10" x 7" Rectangle -- all with a 10" height. I think this would be a good design center.
• All axis are driven from stepper motors through a Spectra fishing line drive on preferably smooth pulleys.
• The two X,Y arms are driven by rotating the elbows. This gives a build area that is limited by an arc from the shoulder with a straight elbow to the hot end.
• The ratio of the stepper drive to large elbow pulley determines the resolution and torque. 0.025mm or better with a reasonable ratio with a 16-32x microstep.
• The Z axis is a 4 bar linkage that keeps the bed flat as it is rotated up and down through an arc. Gravity lowers and a stepper winding a string raises it.
• The build platform moves through an arc as the Z is changed. The X,Y arms have to compensate for the displacement in the Y axis (perpendicular to the back board).
• A convenient place for a spool is on the lower back. Filament would be fed up through a Bowden extruder and over the top and down to the hot end.

Features

• No linear rails
• 28 cheap 608 bearings
• 12 unique plastic pieces (none require support)
• Printable on a 150x150mm machine
• Theoretical speeds in excess of 500mm/s
• Theoretical resolution is less than 25 microns

Wally works on inverse kinematics, In robotics, inverse kinematics makes use of the kinematics equations to determine the joint parameters that provide a desired position for each of the robot's end-effectors. Specification of the movement of a robot so that its end-effectors achieve the desired tasks is known as motion planning.

Once the idea was ready, now its time to divide the task and get started for mechanical design.

1. Develop the Wooden Frame - Fida Hussain
2. XY axis Mechanical Assembling - Muhammad Asim
3. XY axis Mechanical Assembling - Nisar Ahmed
4. Z Axis Mechanical Assembling - Sohail Ahmed Soomro
5. Hot End Extruder Management- Tomas

Well there is quite a bit of help available for this designing this printer, first of all we made a list of the components and materials we will need during the process of making the printer.

Frame Desgning

We started our work, first one was Fida, his task was to cut and assemble frame so that we can further proceed.

All the 3D files related to Wally are available to download from here :

• Back DXF
• Bed DXF

XY Axis Working

Once the frame was ready now it was the time of print the XY and Z axis components their assembly.

Wally places the stepper motors on the walls of the frame to reduce the wieght and allow the arm to move at faster speeds. The position of the arms is adjustable through fishing line drive belt as illustrated below

Design of Wally is a sizeable task. For the mechanical design assignment I and Nisar are jointly responsible for working on the XY- axis movement framework.

The mechanical assembly of XYh movement axis required the following components

Working of the XY Arm

Z Axis Working

It was the process of controlling the Z-Axis and its movement, as in Wally Z-Axis depends on the movement of the bed not the extruder like in the most of other printers. In wally the extruder only moves in XY-Axis.

All the important parts for the Z-Axis 3D printed are here.

Once the Frame part was done, it was now the time to 3D print all the parts, it was the combined and huge task to print all those parts. We printed them after taking a huge time and the materials.

Now it was the time to assemble all the parts

Machine Design

Assembly of a 3D printer is a massive task due to the ultraprecise nature. We had an idea that designing and setting up the hardware will be easy but caliberating software and hardware would be nothing less than challenging. So we just took a big leap of faith thinking that if nothing else we will get a thorough experience.

Task division for this week.

1. Electrnoics and Programming - Fida Hussain
2. Octaprint - Muhammad Asim
3. Preprocessor Programming - Nisar Ahmed
4. Electronics and Programming - Sohail Ahmed Soomro
5. Electrical and Mechanics- Tomas

Hardware / Software platforms

over the past few years numerous hardware/software platforms have appearead for 3d printing. Here we present a brief of the most common hardware / software platforms.

Replicating Rapid prototyper (RepRap) project was founded about a decade ago and this project has evolved massively with world wide interest of enthausiasts. Over time this platform has matured into very stable (feature rich) 3D printers which cost less than 500 USD. In market there exist several varients of freely available software and hardware. Two of the most popular software (firmware) and hardware we came across are listed below:

Software
Hardware

Since support for Marlin is widely available in our fablab therefore there was no discussion for the choice of firmware. There were acouple of RAMPS 1.4 boards available in the 3D printer room and we were lucky enough to borrow them there was no discussion on the choice of hardware either.

The picture is pretty much self explainatory.

RAMPS

RepRap Arduino Mega Pololu Shield, or RAMPS for short. It is designed to fit the entire electronics needed for a RepRap in one small package for low cost. RAMPS interfaces directly onto an Arduino Mega with the powerful Arduino MEGA platform and has plenty room for expansion. The modular design includes plug in stepper drivers and extruder control electronics on an Arduino MEGA shield for easy service, part replacement, upgradability and expansion. Additionally, a number of Arduino expansion boards can be added to the system as long as the main RAMPS board is kept to the top of the stack. The useful user manual for RAMPS is available here.

RAMBo

RAMBo (RepRap Arduino-compatible Mother Board) is an all in one RAMPS class motherboard targeting convenience, reliability, and performance.

Repetier Host    

Repetier-Firmware is a firmware for RepRap like 3d-printer powered with an arduino compatible controller. This firmware is a nearly complete rewrite of the sprinter firmware by kliment which based on Tonokip RepRap firmware rewrite based off of Hydra-mmm firmware. Some ideas were also taken from Teacup, Grbl and Marlin.

Repetier also provides a very handy tool Repetier Host this tool is a ideal platform of basic control and caliberation of the system. This software interfaces directly with the Arduino Mega board through USB interface allowing us to retrieve sensor information and pass G-code scripts. We found the following youtube tutorial very useful to this end.
We used Repetier Host extensively to caliberate the XYZ, Extruder and Endstops.

Marlin   

Marlin is firmware for RepRap single-processor electronics, supporting RAMPS, RAMBo, Ultimaker, BQ, and several other Arduino-based 3D printers. It supports printing over USB or from SD cards with folders, and uses lookahead trajectory planning. Marlin is licensed under the GNU GPL v3 or later. It is based on Sprinter firmware, licensed under GPL v2 or later.

The bill of materials of electronic components necessary for the Wally project is listed here.

1. Electrical Assembly

We started putting together the power supply, stepper motor and interconnection with RAMPs hardware. A good user manual is avaliable at reprap website . After double checking all connections we powered up the circuit.

2. Firmware Setup

The next step was to download the updated marlin firmware from HERE

We also had to study in details the marlin framework to be able to configure the board to operate the stepper motors and hot-end, endstops and thermal sensor information. We took help from the following youtube tutorial.

As this toturial described when we open the marlin project in arduino platform, it contains multitude of files, however only configuration.h should be modified for setting up the system. Most of the features can be activated/deactivated by simply commenting/uncommenting the code.

Our modified configuration file is available HERE .

3. XYZ, Extruder and Endstop Caliberation

Once all the cables were connected we were in a position to powerup the circuit. The next and most important thing was to caliberate the system. Using default feeds and speeds values from firmware or taking values from any internet directly would not work and we had determine them through simple calculations, trial and error.

• For x, y movement we fixed 80 steps/mm this is the default value, the modifications were made in the preprocessor.
• For vertical movement z was altered in a way that total travel length is equal to 15 cm. This was also calculated through trial and error.


• For extruder, we started with the default value i.e. 500 steps/mm in the firmware and tried to extrude the filament of 5 cm, when we uploaded this program the printer extruded 12 cm. So we concluded that extruder steps/mm should be 200. Now with this adjustment we extruded 2cm of the filament and we got the same.


• To determine the maximum coverage of X and Y we used simple calculations. As the stepper motors move 1.8 degrees in one step, so for 360 degrees it will take 200 steps. In the case of wally we can move its arms moves until it makes 90 degrees between the first and second part of that arm, this is also true for Y axis movement as well, so this region is the area where we can move X and Y. We could validate the maximum range of wally using repiter host by through command "M92 X200 Y200 F300". And M500 to save the values.


• Initially the motors were not moving in the reverse direction, we changed the polarity of motor connector but to no avail. Then we made the following changes in firmware which solved the problem.
  #define INVERT_X_DIR false
  #define INVERT_Y_DIR true
  #define INVERT_Z_DIR false
  #define DISABLE_X false
  #define DISABLE_Y false
  #define DISABLE_Z false
  
  


• We have not used the end stoppers, because there is mark given in the joint of each axis which make it on min position and for maximum we have define the limit, if motor moves beyond this limit the system will halt.

Once we got going , we had to write a simple G-code script to test our system. Tomas looked up on the reprap and created this list of important g-code commands which we utilized in our subsequent test scripts.

G-Code preprocessor commands

Tomas spent sometime writing simple gcode script to take wally for a test drive. And the results were encouraging.

4. G-Code Preprocessor

In assignment 5 we came accross G-code which is a simple set of instructions followed by 3D printer to traverse and render filament material. We didn't have deeper understanding of the code before, but to work with a 3D printer we had to delve into details of the G-code and even wrote our own sample scripts to analyze and caliberate our printer. A basic set of commands which we have found very useful are listed above for reference. An exhaustive list of commands can be found here.

Normally, linear 3D printers don't need any G-Code preprocessing, because the z-axis is either static or the extruder moves linearly in the z direction. But in case of the Wally, the bed moves in an arc. So we need compensate for this curvelinear trajectory. Luckily there exist a python script which can compensate these effects.

There are many specific commands provided in the Wally G-Code preprocessor, some important of those are explained here.

These are the bed caliberation points on certain height the value of x, y and z, as the Wally moves the bed in arc so we had to take into account this movements.

For the wally segmentizer to generate accurate code it requires several parameters from the hardware setup. Some of the parameters which we configured listed here:

There are few commands which are important to be explained here:

• l : Length of the arms which is 150 mm in case of Wally
• L : The distance between pulleys which is 250 in case of wally
• y-offset : Thats the distance from bed to center point.
• straight-foreams : The point where the shoulders are straight colinear.
• G1 x(number) y(number) z(number): this is the code used move the extruder to xyz location according the number value provided

The modified preprocessing file considered our printer can be here found here.

Once the modified code is availabe is really makes sense to simulate the code using any of the numerous g-code simulation and analysis softwares to validate the operations because (as in our case) if g-code preprocessor has not been carefully configured the modified g-code may veer completely off course. For a large g-code file it may not be possible to located anamolies without exhasustive review. We found following gcode analyzers.

Interface to Network:

To improve the usefulness of our system we decided to connect wally with a remote computer using octaprint platform. This platform is webserver application running on Raspberry Pi which is connected to a RepRap printer through USB interface. Through this application we can load jobs to a printer remotely and manage/monitor it's performace from a remote location.

We found very good youtube tutorial here

Octoprint:

1. The list of stuff required for octoprinter.
   • Raspberry Pi
   • 8G SD Card
   • 1A 5V DC power supply
   • USB Cable
   • Ethernet cable (Easily Wifi-able)
   • Webcam (optional)
   • PuTTY
   • Octopi 0.13
2. Connections
   

   Electrical Connections to Raspberry Pi.

3. The step by step procedure to setup octaprint server are as follows
   • Download the image file for Octopi 0.13 from here , unzip it and install.
   • Insert your SD Card into the computer and format it.
   • Download the Win32DiskImager-0.9.5-install.exe , and run the program for install the program.
   • Run Win32DiskImager.exe
   • Select your SD Card drive letter in Device droplist.
   • Select the image file that you download from Octoprint. e.g. 2014-06-20-wheezy-octopi-0.9.0.img
   • Click "Write”.
   • When the image is successfully written, Do not remove It from the PC.
   • Open the SD card drive and find the file “ octopi-network.txt” and open it.
   • In "octopi-network.txt" you will find comments, following them and configure it with your internet connection.
   • Now remove the SD card from computer and plug it into the Raspberry pi.
   • Now make the connections and connect power supply, Ethernet cable or Wi-Fi and Arduino mega with raspberry pi as shown in figure given above.
   • Power On the raspberry pi now. And access it from your browser by writing http://octopi.local
     

     Login screen

You can also access the octopi server from "Networks" Option in My PC of your operating system.



Access to Raspberry pi from windows network.

4. After opening the webpage of octoprint, the first thing to do is to set the username and Passward.
   
   

   Access to Raspberry pi from windows network.

5. The last step is to log in to the octoprint webpage and click on the connect button to make connection with the printer. You can set any baud rate from the group of given baud rate. We are using 115200. Octo printer is ready now, just drag and drop your gcode file and hit print to start.

Suggestions for further improvement

Wally has been a very rapid project. Although its more of assembly and caliberation based project. This project has been a wonderful opportunity for us to learn variety of things related to machines that make machines.

1. The output quality of system could be improved through further fine tuning of the system parameters.
2. The printing tray is not perfectly flat and this problem surfaces.