Design for Control of 3-D Printer with Two Different Print Heads
Design Team #11
Sponsor: MSU Technologies
Facilitator: Chuan Wang
Annalin Davis
He Chen
Michael Saybolt
Joshua Folks
Matthew Luzenski
April 29, 2015
Executive Summary
MSU Technologies would like a 3-axis gantry developed that can be used as a positioning
platform for a multi-head 3D printer. The end goal of MSU Technologies is to make this device
capable of printing a range of materials, from plastics, to metal deposited through plasma. Due
to limitations on design constraints for the plasma deposition head, the task is to make a machine
capable of handling the use of this head once it is completely developed.
A user friendly software setup is also required to use the 3D printer. Hardware compatibility
with open source software or APIs is desired and was taken into account in the part selection
process. Multiple design options have been considered and purchasing and modifying a Wanhao
Duplicator 4S 3D printer is the most time and cost effective solution to have an operating gantry
to build on. To make the printer adaptable to the plasma deposition head, multiple pieces of
software have been implemented both in the CAM program itself as well as an easy to use Gcode postprocessor run externally. At the project end date, the device will be capable of
accurately positioning two print heads for a proof of concept demo of 3D printing metal with
plasma assisted deposition of metals.
Acknowledgements
We would like to acknowledge and thank MSU Technologies for the opportunity to work on this project,
Dr. Timothy Grotjohn for his academic insight and continued support as our project sponsor contact as
well as our ECE 480 professor, and Dr. Chuan Wang for his advice and guidance as our project
facilitator.
1
Contents
Chapter 1....................................................................................................................................................... 3
Introduction .............................................................................................................................................. 3
Background ............................................................................................................................................... 4
Chapter 2....................................................................................................................................................... 5
Design Objectives ...................................................................................................................................... 5
Conceptual Designs ................................................................................................................................... 8
Design Solution ....................................................................................................................................... 12
Budget ..................................................................................................................................................... 13
Gantt chart .............................................................................................................................................. 14
Evidence of Success ................................................................................................................................ 15
Chapter 3..................................................................................................................................................... 15
Hardware ................................................................................................................................................ 15
Software Logic......................................................................................................................................... 16
Software Interface .................................................................................................................................. 19
Problems Encountered ........................................................................................................................... 22
Solutions to Problems ............................................................................................................................. 24
NX ............................................................................................................................................................ 25
Optimizations .......................................................................................................................................... 26
Test Circuitry ........................................................................................................................................... 27
Chapter 4..................................................................................................................................................... 28
Test Data ................................................................................................................................................. 28
Plasma Head Implementation ................................................................................................................ 30
Proof of Functional design ...................................................................................................................... 31
Chapter 5..................................................................................................................................................... 34
Summary ................................................................................................................................................. 34
Appendix 1: Technical roles, Responsibilities and Work ............................................................................ 36
Appendix 2: Literature and Website References ........................................................................................ 41
Appendix 3: Technical Attachments ........................................................................................................... 42
2
Chapter 1
Introduction
In recent years the field of additive manufacturing, or 3D printing as it is often referred, has
grown into a publicly available and affordable process. The process has wide applications in
manufacturing of parts made from many materials for rapid prototyping and structural
complexity. MSU Technologies would like to get involved by incorporating its plasma assisted
deposition of metals research project into a 3D printer. This design team is tasked with creating
or modifying a desktop scale printer for use in printing both metals using the plasma deposition
method and plastics using the standard fused deposition modeling technology. Additionally,
easy to use software needs to be created to make the machine work properly.
While it is currently possible to print metals using a different method, it is the combination of the
two materials into a single printer that is novel and desirable for more unique part fabrication.
The ability to create a part that is made of both metal and plastic is desirable in many
manufacturing processes. The end goal is to show that conductive parts surrounded by an
insulator (plastic) can be made with this printer in the hope the process can be profitable for sale
to an outside entity.
The metal deposition process occurs on an atomic scale so it will be very slow and produce thin
layers. To ensure the integrity of the metallic components in the produced piece, the plastic
layers that it will be printed on must be as smooth as possible. The controller must also allow the
rate of printing to be adjustable for both materials to keep completion times low but still allow
the metal to be produced properly.
Furthermore, the printer must be easily modified to accommodate the mounting of the plasma
head and maintain a print range of around 150 × 75 × 150mm. Since the plasma deposition head
design has not been finalized as of the completion of this project, a plastic object has been made
that demonstrates the maximum size and fixture locations of a future plasma head.
Finally, the software interface must be user friendly and simple so that parts are produced exactly
as desired with ease. Because the plasma head will not be ready by design day, a proof of
concept will be presented by demonstrating printing with two extruder heads or one plastic
extruder and one plastic model of the plasma head. The plasma head’s maximum dimensions
were created from the maximum clearance of the extruder carriage at the extremes of x-y
positioning. The output signal of the printer controller is also analyzed and reported so that the
plasma head can be controlled by the printer. At the end of the project, the design will be capable
3
of accepting any physically and electronically compatible print head. The ability of the printer to
create parts with different layers and thicknesses will be thoroughly tested.
Background
There are other 3D printing systems out there that have dual extruder heads or multi-material
capabilities. Stratasys makes multiple printers that can print a variety of different plastic
materials. The Objet Connex 350 is one of them, and according to the manufacturer's website,
can print over 140 different types of resins [1]. It has two heads to deposit a mixture of materials
to have even more combinations of materials and properties.
Printing metal is an entirely different process and requires the use of a high powered infrared
laser guided by a laser galvanometer to quickly and precisely fuse powdered metal particles
together [2]. This is referred to as Direct Metal Laser Sintering (DMLS) and there are variants of
this process that can work on plastic, however they are generally not combined.
A new idea has recently been proposed that uses plasma to transfer suspended metal particles to
a surface, enabling transfer well below the material's melting point. While the Connex 350 prints
a variety of plastics and a DMLS printer can print metals, neither can do both. This new process
makes it feasible for use on plastics, as well as metals, thus making a truly multi-material 3D
printer possible.
MakerBot (recently acquired by Stratasys) claims to be the industry leader in desktop 3D
printing, using a Fused Deposition Modeling (FDM) technique where spools of plastic are fed
through an extruder that is guided by a Computer Numerical Control (CNC) gantry to make
layers which are built up to make a complete object. While much less accurate than most resin
based printers, the FDM process is much cheaper, and an FDM printer provides the perfect
hardware configuration for mounting a plasma deposition head, which is the goal of this project.
This project involves building some sort of 3 axis gantry, and making it suitable for use with the
plasma deposition technique. It will be tested by using two FDM heads to extrude two different
color plastics to demonstrate the accuracy of the two heads working in conjunction with one
another.
Once the 3D printer gantry is assembled and the extruder heads mounted, software is required to
turn an object into toolpaths, or G-code. The software must also be able to generate two
different toolpaths for the right and left extruder head, or plasma deposition apparatus.
The end result should be a 3 axis gantry sporting a custom mounting carriage that will be able to
print two different color plastics. The FDM extruder heads can then be removed and replaced
4
with the plasma deposition setup and should be able to deposit metal or any other printable
material with the same accuracy as previously demonstrated with plastic.
The goal for this project is to design a modular 3D printer with capabilities of expanding to
different materials using interchangeable heads. Thanks to MSU Technologies, the development
of the metal deposition head will be the first third-party head designed to work with this printer
giving it metal printing capabilities.
Chapter 2
Design Objectives
Careful consideration needs to go into choosing a 3D printer for this project. In order to meet the
design requirements, the 3D printer that is chosen should be accurate, have dual extruder heads,
and be easily modified and compatible with available open source software. The cost of 3D
printers varies greatly due to the number of features available. This will be taken into
consideration when comparing potential 3D printers.
Accuracy is needed to produce usable products. Future applications include printing a very thin
layer of metal with extremely low tolerances for error. Accuracy can be improved by examining
several features. Using extruder heads with smaller nozzle diameters will allow more precision
and control over the shape of the final printed part. Also, a 3D printer with a bed that only moves
on the z-axis is more accurate than a 3D printer with a bed that moves along the x or y-axis.
Reducing the degrees of freedom of the bed and the weight carried on top of it minimizes
backlash in the system and the need for frequent recalibration. While this is an issue that can be
resolved, it is much more efficient to have the bed only move on the z-axis.
Dual extruder heads allow the 3D printer to print two different plastics, or two different materials
at the same time. Buying a printer that already comes with dual extruder heads installed saves
time that would be used modifying a single extruder head printer. This time could be used to
focus on the future applications of the printer or other aspects of the project. It also makes
replacing heads considerably easier as the space and carriage are already designed to fit two
extruder heads.
Adaptability of the 3D printer is necessary to make modification possible to comply with design
standards. This is especially needed for 3D printers that require the installation of a second
extruder head. A 3D printer’s adaptability relies on how large it is and how open the chassis is,
as these qualities provide more space for installing an additional extruder head, and reduce how
much real estate has to be sacrificed.
5
The 3D printer should be compatible with software that is easy to use and easily modified. The
software may need to be modified to have the ability to generate code for use by dual head
extruders, print plastic in a more specific way than the default setup allows, have longer pauses,
and/or longer or shorter height adjustments.
3D printers can be found in a very large range of prices. To be efficient in the price category, a
printer must offer many of the desirable qualities for a competitive price. A printer will be
chosen that matches the most of these qualities while staying within budget. A FAST Diagram
detailing the goals of the project can be seen in Figure 1. A summary of the design requirements
includes the following:
 Limit project spending to $1500.
 Develop a printer to handle different materials with different feed rate and extrusion
diameter.
 Creating standards for different head design for unlimited possibilities.
 Develop user friendly user interface for calibrating developmental printer heads and
general use.
 Create standards for inputting modeling files (STL) for slicer programs.
 Modify currently available slicer programs to be compatible with different materials and
heads.
 Investigate and improve bonding properties for printing metal and plastic together.
The sponsor had three main goals for the 3D printing project: to create a program that is easy-touse, test printing plastic over metal, and to consider the thinness of the metal when creating our
prototype. The sponsor specified that an adequate demonstration for this project would be to
have a 3D printer print two different colors of plastic in one piece. These goals were expanded
into design objectives as shown in the house of quality (Figure 1).
6
Figure1: House of Quality Diagram
These design objectives shown above were used to judge the hardware and software solutions.
Three conceptual designs were created based on three different 3D printers. Details about each
printer will be provided along with a concise explanation of additional tasks that would need to
be completed to create a suitable prototype.
Software also needs to be chosen to go along with the printer. Most softwares are already fairly
user-friendly. After adding in more functionalities and customizations, the program should still
be just as user-friendly as when it started. Some softwares already have built in functionality for
operating a 3D printer with two print heads. This is an ideal starting point for the project. It
allows more focus to be given to the other features that will be implemented. The software needs
to be modified to allow the user to choose what material each print head uses. It should also
7
allow the user to edit the temperature of the print head, speed of the print head and how many
layers the print head should lay down per pass.
Conceptual Designs
The first conceptual design is built around the ORD Bot Hadron 3D printer mechanical platform
(see Figure 2).
Figure 2: The ORD Bot Hadron 3D Printer Mechanical Platform.
This model is just the chassis for a 3D printer; it still needs extruders and a microcontroller. The
extruders would need to be mounted and calibrated. The mounting for the extruder heads is large
and open, making it easy to attach a different printer head. The mounting may need a little
reinforcement. A microcontroller and corresponding software would have to be chosen for this
printer. The microcontroller would have to be attached, and software installed and tested. To
account for the moving bed of the 3D printer, the software would also have to be calibrated to
help deal with the inaccuracy.
8
The base for the second conceptual design is the Asterid 1000HB 3D printer (See Figure 3).
Figure 3: The Asterid 1000HB 3D Printer.
It has dual extruder heads, a microcontroller that comes with its own software and a moving bed.
To modify this 3D printer to fit the purposes of the project the following tasks would need to be
done: Creation/modification of a carriage to allow interchanging of extruder heads and
calibration of software to account for inaccuracies due to the moving bed.
The Wanhao Duplicator 4s is the base for the third conceptual design (See Figure 4). It is a
sturdy printer with a bed that only moves in the z-axis.
Figure 4: The Wanhao Duplicator 4S 3D Printer
9
It comes with a microcontroller that is compatible with multiple software options. This printer
would not need much done to its hardware, but would still need work for the software.
To focus on the key aspects of what needs to be done, a FAST diagram was created (Figure 5).
The creation and design of a metal print head is the responsibility of another research group. Our
focus is on the software side, and providing options to make printing other materials easier.
Figure 5: Fast Diagram
The highest ranking design is the Duplicator 4S. This is a 3D printer with high accuracy and
potentially high precision. The build platform is attached to the z-axis which will eliminate the
weight of the object as a factor in causing backlash. The dual extruder head is already included
with the Duplicator, so an additional one will not need to be purchased. While this printer has
the bulkiest chassis, it is still adaptable enough to satisfy the interchangeable print head design
objective. The microcontroller for this printer is compatible with multiple open source softwares.
This printer meets most of the hardware requirements and software requirements for the design
solution.
10
The second highest ranking of the conceptual designs, the Asterid 1000HB, fell short of the
ideal. The main issue with this 3D printer is the build platform. This build platform moves on the
x-axis which causes the weight of the product to affect the accuracy and precision due to
backlash. This is not ideal for the future prospect of printing metal. However, the adaptability is
very high with an open chassis and it will be able to print a large size object. This model is also
software friendly as well as being inexpensive.
The lowest ranking design, the ORD Bot Hadron, had drawbacks in many important areas. The
cost is very inexpensive and with a tight budget, this 3D printer seemed like a reliable option.
The adaptability is the most impressive area of this printer; it has a very open chassis and a
mount that should hold most extruders, including a dual extruder set-up. However it does not
come with any extruders or a microcontroller. The poor accuracy, and amount of extra time that
would need to be spent installing and testing the extruders and microcontroller makes this design
unfeasible for the timeframe of the project. The software would need to be chosen based on the
microcontroller. Overall, this printer will only dent the customer needs.
An overview of the rankings of the printers with weighted importance of the design attributes is
displayed in Table 1.
Engineering Criteria
Importance
ORD Bot Hadron 3D
printer
Duplicator
4S
Asterid
1000HB 3D
Printer
Accuracy
5
3
9
3
Dual Extruder Heads
3
1
9
9
Adaptability
3
9
3
9
Compatibility with
available software
4
9
9
3
Price
2
9
3
3
99
123
87
Totals
Table 1: Solutions Matrix
11
Design Solution
The goal is to have a 3D printer capable of printing different materials in one given structure
using interchangeable extruder heads. The hardware solution will consist of modifying a 3D
printer that will include two interchangeable print heads. The Wanhao 4S Duplicator was chosen
as the 3D printer, its specifications are listed in Table 1. It will be calibrated to have a high level
of accuracy, create a smooth surface, and be precise. These features are necessary due to the
plans that MSU Technologies has to integrate a Plasma Deposition Print Head, used to print
metal. Introducing a Plasma Print Head will require a custom made mount that will be placed
inside of the printer. As far as construction, the printer purchased will be fully assembled. There
will be an initial test to ensure full functionality of a normal 3D printer. The extra print head and
mount would then be designed and fabricated. The custom made mount will be 3D printed or
made in the machine shop.
The software solution is more complex and will allow the user to operate the 3D printer with a
user-friendly interface. The software will have the following settings added to it: multipass,
extruder temperature, material selection, and layer height. More settings and options will be
added if it becomes apparent that they are needed. Multipass and layer height are two ways of
achieving a similar goal. The goal is to have the metal print head print more layers for every
layer of plastic. Using multipass the user would say how many times they wanted the printer to
print each layer, while adjusting the layer height will change the G-code to make the extruder
head move by smaller increments while printing the metal, effectively forcing it to make
multiple passes. Extruder temperature is a setting that is already available in the code, but it may
be beneficial to have a setting to turn off the heating element for one or more of the print heads.
A material selection option could be very user friendly. Installing a drop down menu that allows
the user to choose their material for each extruder head and preloads in defaults for that material
will save the user a lot of time. These users will still be able to edit these values if something
needs to be changed.
As far as the main interface for the 3D printer. The solution that was chosen was ReplicatorG.
Among all of the different options, ReplicatorG is the most easily understood and has the most
compatibility with the printer. The options that the interface offers for the printer include,
changing the print head speed, choosing the material for each print head, setting the infill, and
even choosing the type of support that each print should have. The slicer that was chosen to work
with ReplicatorG was Skeinforge. This has been written in python, which means if there needed
to be alterations to the code it would not be impossible to complete.
Once the software and the hardware designs are completed and working together, then the testing
of the solution will commence. The initial testing will include using the 3D printer to construct
an object using two different plastic materials. This test will show that the interchangeable
12
extruder heads are working simultaneously. There will also be tests to simulate metal to plastic
bonding. Printing on conductive ink or inserting a circuit design within a print will be very
exceptional to show hardware and software functionality. These tests will deliver a simulation
that will yield a success or failure similar to the customer requirements. The custom mount and
the software interface design will be tested thoroughly to determine if they have been modeled
correctly. The proposed design solution would then be capable of meeting all requirements and
suggestions made by the customer.
Budget
The needed materials for this project and their corresponding costs are listed in Table 2. The
Duplicator 4S was the best choice for 3D printer, as detailed above it meets the requirements
better than any other solution. Printing materials, such as PLA and ABS, will be needed to test
the printer. It costs around $20-$50 a roll depending on material. Buying a few more rolls of
different materials for testing purposes may be necessary so $100 of the budget was allocated to
this purpose. In the case that one of the extruders breaks or another is required for testing
purposes we allocated another $100. If the software for the microcontroller proved to be too
difficult to edit or isn’t working for this projects purposes a new microcontroller could be
purchased. To complete this project a new mount may have to be made for the print heads, this
should not be too expensive and could potentially be 3D printed. Another consideration is given
towards the software being incompatible with the project’s needs. For this, and for future tests
that may need materials that have not been mentioned, there is an extra $200 in the budget. The
actual budget required few purchases outside the printer itself and the printed material and was
much less than the expected value (Table 3).
Material
Duplicator 4S
Printing Materials
Extra Compatible Extruder
Different Controller
Mount for Print Heads
Miscellaneous/Software
Total
Cost
$1000
$100
$100
$70
$30
$200
$1500
Table 2: Projected Budget
13
Material
Cost
Duplicator 4S
$949
Printer Filament
$114.38
Tools
$29.86
Printer Materials $35.71
Total
$1128.95
Table 3: Actual Budget
Gantt chart
Figure 6: Gantt chart breakdown
Figure 7: Gantt flowchart
14
Evidence of Success
Success is determined by the ability of the design to complete the design objectives. As it
stands, the printer is correctly operating with both extruder heads allowing the machine to be
used for multiple materials. Since the plasma deposition head is not complete yet, actually
printing metal is not required; however a proof of concept by printing plastic over some preplaced metal is sufficient.
The user interface for the G-code postprocessor is easy to use and works under a variety of
conditions and computer CPU loading. All features have been implemented and tested for
success. The printer is also calibrated correctly for accurate plastic extrusion.
Chapter 3
Hardware
The hardware chosen for this project is the Wanhao Duplicator 4S. This 3D printer was picked
because it has a solid metal chassis, an open area for adding modifications, and already has two
extruder heads in one package, saving money by not needing to buy an additional separate head
which generally costs more. It also contains an ATmel ATmega 1280 microcontroller as its
main control board which is capable enough to handle G-code interpretation and additionally has
some room for expansion for actuation of additional hardware if necessary.
A glass plate is used on top of the aluminum heated build platform to provide a more uniform
printing surface. While the firmware loaded onto the microcontroller features a Z offset feature,
it ignores the offset when zeroing the printer, resulting in the extruder head hitting the build
platform which could damage it over time. This is remedied with a spacer inserted behind the
build platform to trigger the Z zero end-stop prematurely, causing it to set the height of the
platform with the glass as its zero point -- a hardware offset.
15
Software Logic
The software logic is responsible for converting STereoLithography (STL) files, a standard 3D
modeling file format into machine instructions that 3D printer. Wanhao’s Duplicator 4S uses Gcode as the machine instruction language. G-code is universal to most consumer 3D Printer as
well as most CNC. The software should consist of two parts the interface and slicer. The
interface is responsible for taking user inputs to control the output of the G-code file as well as
communicating between the user’s computer and a printer. The Slicer is responsible for taking
in STL file and user settings and outputting G-code for the printer. It does this by taking in the
3D model and “slicing” the 3D model parallel to the XY plane. The thickness of each slice
depends on the user input. Once a slice is made the Slicer algorithm calculates a toolpath that
will create this sliced model. The slicer has to determine the correct amount of material to
extrude at each individual point as well as the optimum tool movements. The Slicer can also
optimize the internal structure of a part to save material and time. The default logic for
converting 3D model to physical model is as follows:
ReplicatorG is used as the interface for our project. ReplicatorG is an open source software that
Wanhao designed their Wanhao Duplicator 4S to be compatible with. The currently version is
ReplicatorG is fully compatible with our printer however it does not have all the features that are
required for this project. The two additional functions that need to be implemented for this
project are complete control of both extruders and bed as well as multipass functionality for print
head that prints smaller thickness resolution that what the printer can provide. In order to
implement these we have the option of modifying the Slicers logic (Skeinforge) that ReplicatorG
uses or modify the output G-code file to implement features to the printer that are not available.
Due to the complexity involved with modifying the Slicer logic, custom software that modifies
the G-code output of the Slicer is easier to implement. This requires complete understanding of
the output file and editing it such to implement complete temperature control and multipass
capabilities. The following is our design logic for the 3D printing process.
To implement the design logic, changes must be made within the ReplicatorG source code as
well to fully integrate the custom G-code Editor.
16
For the default ReplicatorG once a STL file opened in ReplicatorG, the G-code file can be
“Generated”, after the user input in the desired settings. Once the G-code file is created
ReplicatorG automatically loads it into the UI and then this file can be loaded onto a SD card
destined for the 3D printer. To integrate the G-code Editor, an exact copy of the G-code that is
currently on the UI of ReplicatorG must be copied onto a known and constant directory for Gcode Editor to alter. Once the file is altered a method needed to be used to reload the file onto
ReplicatorG.
The first step of solving this issue is finding all the possibilities that will cause ReplicatorG to
change its G-code displayed on the UI. The cases that will cause these states are:

Opening new file

Editing inside the UI

Generating new G-Code

Updating our edited G-Code onto ReplicatorG. Once we edited the G-code and
update in ReplicatorG, logic must be implemented to disable the edited code from
being edited by the editor again.
The solutions to these cases are as follows:
 Opening new file: Once a new file is opened, a code is implemented to copy the file that
the user chooses to open onto a known directory and name.
 Editing inside the UI: Once an edited file is saved, this triggers the program to copy the
entire file into our known directory and name.
 Generating new G-Code: G-code is output from the slicer one line at a time. A code is
implemented inside ReplicatorG to record each line’s output into our known directory
and name.
 Updating our edited G-Code onto ReplicatorG: Once a file is edited, a header is created
to mark this file is edited. Our editor will only edit files that do not contain this header.
Once the file is edited and available in a known directory, a method must be implemented to load
the file back to ReplicatorG. Initially a code was implemented to load our edited file onto
ReplicatorG once “load file to SD card” is utilized. Thus every file we load onto a SD card will
be the edited file. However this logic fails if the user decides not to activate our editor for a
normal plastic print. Thus we implemented an “Update G-code” option onto ReplicatorG so the
user can choose to when he/she desires to use our edited file or not.
The logic for generating new G-code was first implemented in C++. The inputs are listed in the
table below.
17
Text File
The file containing the original G-code
Integer
Left extruder temperature
Integer
Right extruder temperature
Integer
Bed temperature
Boolean
Left extruder temperature on/off
Boolean
Right extruder temperature on/off
Boolean
Bed temperature on/off
Boolean
Multipass feature on/off
String
Multipass on the left or right head
Integer
# of layers to print
The program would read in the text file and all of the parameters. It opens up the text file and
goes through the original G-code line by line. For each line it checks the MCode or G-code on
that line. If it is “M104” then that line would set the temperature of the extruder heads. The
program then looks at the next two words, these tell the program what tool is being set, and what
temperature to set it to. An example of a line of G-code setting the temperature of an extruder is
shown below.
M104 S100 T0
This code will set the temperature of tool 0, or the right extruder, to 100 degrees Celsius. The
number following ‘S’ is the temperature and the tool to use is designated by a 0 or a 1 following
‘T’. For the Wanhao 4S 3D printer, T0 typically refers to the right extruder and T1 refers to the
left extruder.
The program then checks the parameter for this tool to see whether the temperature should be on.
If it is not supposed to be on, the program proceeds to the next line of the file. If the temperature
is supposed to be on, it checks the parameter for temperature for this tool and writes a new line to
the output file. The line has the same M-code and tool identifier, but it has the new temperature
option specified by the user.
The program does a similar routine for setting/turning off the bed temperature. The only
difference is that it looks for “M109” instead of “M104”. The bed also has a tool associated with
it. This is chosen by the original G-code and for simplicity, it is allowed to stay the same.
18
To create a multipass function for the printer, the program has two requirements. The first is that
the printer only switches tool heads between layers, meaning that it completely prints one layer
with one tool head before printing the layer with the other tool head. The other requirement is
that each tool head’s first move is to move to the starting position for printing. This allows the
program to detect the tool change commands, “M108”, and repeat everything in between the tool
changes.
The entire code can be seen in Appendix 3. However, this code only works at command line and
therefore is not very user-friendly.
Software Interface
In order to cater the software to the 3D printer and the requirements for plasma deposition print
head, a user interface must have been created as mentioned above. The software requirements are
not based on a true specific product, but it involves performing a service to create a product.
Microsoft Visual Studio was used to create the user interface and develop the logic that provides
the functionality to the application. The design constraints that were faced during the design
process included implementing a high level of ease with use and also making it intuitive. The
logic of this application is to edit the G-code that ReplicatorG produces based on the users input.
The interface had to support the ability to change the temperature of the extruder heads, both left
and right, and the bed temperature. The user is given the option to either turn off the extruder
head/bed or set your own desired temperature for either one.
Figure 8: Editor Initial Window
The interface operates by opening a simple window that gives the status of the application. As
seen in Figure 8, the program states that it is not running and allows the user to the application
with ReplicatorG. Once the user decided to run with ReplicatorG, and then the Printing
Alterations window will appear. This is where all of the changes to the G-code take place.
19
Figure 9: Editor Temperature Options
The first tab that is shown in Figure 9 gives options for the temperature control of the 3D printer.
If the user decides to turn off the temperature for any of the given elements for the printer then
the input box will be disabled. This removes the confusion that the user may have when setting
and when the disabling the temperature.
Figure 10: Editor Multi-pass Options
Another feature that the user interface implements is the multipass feature. This feature is
designed solely for the interchangeable plasma deposition print head. Because the plasma head is
anticipated to print a metal-based element where the metal is being placed on an atomic scale, as
stated before, this feature will be able to enhance the visibility of the metal. The stream of
metallic atoms onto the plastic surface will be traversed more than once with multipass. The user
can choose to pass over a line six times if that would be the necessary lines in order to make that
part visible. The interface, shown in Figure 10, will allow the user to turn this feature on and off.
20
If the feature is off then nothing else can be done in the current tab. However, if multipass is
enabled then the user can choose if they want to use the left or right extruder as the plasma print
head. There is no reason for the user to want to use both since metal will only be extruding out of
one print head. This increases the ease of use for the user, removing any confusion. Once the
extruder is selected then the number of passes requested over the same line is then inserted.
After all the desired changes to the G-code and the overall quality of the print are made, then the
user can select to apply the changes to the G-code. This will close out the Printing Alterations
window and then commence the running with ReplicatorG. The window will now reflect the
status and change to what is shown in Figure 11. This will be the appearance of the remaining
main window for as long as it remains open. The options button will be used to access the
Printing Alterations window and make changes as necessary.
Figure 11: Editor running with ReplicatorG
“Running with ReplicatorG” is essentially stating there are background changes being made to
files. The application has to keep track of the file that it is editing and the original file.
Code.gcode is the original file that is produced in ReplicatorG and the edited version of the Gcode is referred to as Edit.gcode. After the changes have been applied, the application then goes
into a continuous loop. This loop is very important to the functionality of the user interface and is
repeated every quarter of a second to ensure that it is catching every change made as soon as they
occur. The loop begins by checking to see if a Code.gcode exists. This is the file the ReplicatorG
produces based on the model the user desires to print. If it cannot confirm that this file exists
then nothing happens and the application continues to search for it periodically. After the
confirmation, then the searching for Edit.gcode will commence and if that is not found then it
will go through the process of creating one based on the user’s requested changes. If there is an
existing Edit.gcode then the application decides if it is up to date with the changes that are made.
After every time a change is made to the print settings, a string is put at the beginning of the file,
“(edited)”. This will tell the loop that the file has been caught and edited.
The loop that the user interface uses is continuous as there is a delay. The delay is implemented
so during the loop there is not much busy waiting and the user is able to still use the application
in any way they desire. The loop takes the current time of the day and the adds 250ms and then
waits till the current time is equal to the new time. Once this happens, the loop then continues to
21
run. The fact that the busy waiting would not be a problem was a crucial design constraint
because the user should always remain in control of the application.
There are a few situations that we had to account for in the user interface in order to keep the
ease of use high. ReplicatorG produces G-code based on the model that is imported. If the print
requires dual extrusion then there are G-codes that are produced for each print head. This is done
because there are different settings for both that can be altered. The application is only able to
read in one file in order to make the necessary changes. The two G-codes are combined after the
last one is finished generating. However, if the user wants to make changes to the overall print
before the last G-code is generated, the application will try to apply the changes to the
incomplete version. To prevent this from occurring, we added a provision in the code that checks
for a final version, based on formatting, until it will make the necessary changes. Every feature
of the user interface is to assure a high level of user friendliness.
Problems Encountered
Throughout the design implementation, numerous problems were encountered both hardware
and software related. Some were expected, others were not.
Starting out with hardware issues, the heated build platform exhibits warping when heated. This
is because of a fundamental design flaw of the Wanhao Duplicator 4S along with the MakerBot
design it was based off of. The build platform is heated by running current through a PCB
located underneath the aluminum plate. The PCB is secured to the aluminum plate by 11 screws.
As the platform heats, it expands more rapidly than the PCB causing the platform to bow up
towards the middle of it and sit lower near the ends. This causes leveling and calibration issues
because if one part is level, the rest of it is not.
To make matters worse, the amount of deflection changes with temperature, so an offset could
not be programmed into the software because it varies greatly, and would take too much time to
study and implement.
Another physical issue was the part of the chassis that the build platform is attached to exhibits
warping. The deflection was enough that the adjustment springs could not extend far enough to
level the build platform.
Assuming all printer variables are controlled and accounted for, there are additional issues with
the plastic filament. To save cost, cheap filament was purchased without being aware of the
consequences. When filament is manufactured, it starts in raw pellet form and is then fed into an
extruder, similar to that of the 3D printer. The plastic flows out of the desired diameter nozzle
22
where it cools briefly and is wound onto a spool. Cheaper filament tends to have less quality
control over this process and can end up tangled.
When a snag is encountered, the printer attempts to pull the filament through, but fails causing
the aggressive feed gear to strip off plastic and deposit it around the inside of the extruder head.
This makes a little bit of a mess and eventually requires removal for proper feeding. Because
plastic is not being fed and the feed mechanism is an open-loop system, the printer keeps moving
as normal but does not deposit any plastic onto the build.
When long prints are required, such as for the physical model of the maximum size of the plasma
deposition head, which took over 12 hours, multiple snags can be encountered ensuring a failed
print. This leads to wasted plastic and time, if the tangled filament is not noticed immediately.
If it is noticed immediately, the print can be paused, filament trimmed and untangled, and then
resumed where it left off, usually keeping most of the part’s structural integrity intact.
Prior to calibration, the printer could not print a 20mm test box without leaving excess filament
on the top and sides. While less than 100% infill will allow excess plastic to be concealed within
the part, for the system to be robust, it should work properly on all infill settings.
As previously mentioned, a glass plate was used to provide a more uniform printing surface to
increase plastic adhesion. This adds approximately 6mm to the height of the build platform.
When the printer is zeroed/homed (sent to maximum coordinates until switches are depressed) at
the beginning of a print, the firmware ignores any Z offset input. It has a feature to offset the
build without adjusting the G-code, however its designers neglected to realize that if there is an
offset, it is most likely used because there is some kind of obstacle present. As a result the print
head makes contact with the build platform which stresses the parts of the printer and could
damage it over time.
During modeling of the printer extruder heads and mounting of the theoretical part that was
printed, the left plastic extruder assembly was removed a number of times. There are several
wires that are routed in between the two extruder assemblies in which there is very little room
and the wires are pinched. Among these wires are the high voltage leads for the heating elements
located at the extruder nozzle. In the process of replacing the left extruder one of plastic sheaths
protecting the pinched lead split and its 24 volt signal was passed to the entire carriage. Both
extruder assemblies and the carriage were electrolyzed when they should be grounded. The
Wanhao Duplicator 4S design had a number of flaws but none were more dangerous than this.
When the next print began there was an arc of electricity between the nozzle and the build plate
and the printer received an “SD Card Read Error” and canceled the print. With a multimeter the
carriage was confirmed to have a 24 volt signal and the printer was disconnected from power.
The left extruder assembly was removed again and the issue was gone, both the carriage and
23
extruders were ground again. At this point the broken wire cover was noticed and covered with
electrical tape and the issue was recorded and resolved. It is important to note that because of the
shortness of the heater wires they must be placed between the extruders and this issue can
happen again overtime. Occasionally the extruder voltage should be checked to be sure there is
no significant voltage that could create an arc and harm the operator or damage the printer.
On the software side of the design process, there was a major problem with the user interface.
The loop that continuous has the program searching for the Code.gcode and the Edit.gcode was
more complex to implement. The loop completes and then every quarter of a second it runs again
to perform the same operations. As stated before, there must be a delay that is involved in order
to have this feature. The delay still gives control of the application to the user instead of just
using busy waiting until the delay or the loop is over. The problem is with the loop running
continuously; the thread is maxed out by the operations of the loop. This is a design issue
because depending on how many processors that the computer possesses, it could run very slowy
while doing anything else. The loop completely takes the use of one thread and that thread
cannot complete anything else.
Solutions to Problems
To fix the issues encountered required both hardware and software modifications. To fix the
warping build platform, a glass plate was secured to the build platform using clips.
Alternatively, the holes could be drilled out in the PCB allowing it to expand at a different rate
than the aluminum plate above it. If the glass plate did not work, the PCB modification is
another viable option. New springs were ordered to compensate for the distorted chassis,
however the chassis later un-warped and the springs were not necessary. The springs were
installed anyway in case the chassis experiences warping again.
To solve the twisted filament issue, it is recommended to purchase quality filament from a
reputable manufacturer. A temporary solution is to install the spools on some kind of axle away
from the printer. This helps them unwind easier and also provides the user with more warning if
the filament hits a snag, because it will drag the filament off of the axle. The printer can then be
paused and the tangled part resolved.
The bulging 20mm boxes were fixed by editing the slicer profiles. Upon clicking, a dialogue
box opens where different plugins can be activated. In the “Fill” plugin, the “infill perimeter
overlap (ratio)” was changed from 0.6 to 0.1. This controls how much overlap is present
between shells. It should be noted that the parameter, “infill solidity” appears to do nothing.
24
In the “inset” plugin, the “Overlap removal width over perimeter width (ratio)” was changed
from 0.4 to 1.0. It should also be noted that the “Infill width over thickness (ratio)” used in
previous versions of ReplicatorG appears to not change anything in the output file.
Lastly, in the “dimensions” plugin, the “filament packing density (ratio)” was changed from 0.87
to 1.0. There was an excess of plastic because the software uses this number to determine how
much plastic should be extruded. Because it was set to less than one, it extruded more plastic
than necessary to make up for reduced density. Changing this number to one had the biggest
effect on the quality of the print.
Besides from calibrating from software aspects, physical calibration of the printer is needed as
well for accurate printing. The most important of which is the Z-level leveling. Due to the dual
extruder nature of our printer, it’s crucial each extruder is at the same Z-level. To calibrate this,
the build plate must be level first as stated above. Once the built plate is level, if the printer
moves to Z=0mm plane then the nozzle must be just touching the build plate. This is done by
adjusting set screws for each of the extruder.
The firmware’s failure to adhere to offset inputs was resolved with a hardware approach. A
spacer was designed and printed on another 3D printer and secured into the proper position.
To solve the issue involving the software loop, many solutions were proposed such as different
delay methods and loop method. Putting the thread to sleep for a quarter of a second was one of
the first solutions that were tested. This did not work, as the operating system was never clear as
to when to wake up the thread from sleep. Another solution that was proposed was to implement
a system pause or wait call to the operating system. It seemed to work initially until the control
of the application to the user was lost. This is a huge problem because the user should always
remain in control and to make the necessary changes. To solve the problem, a compromise
needed to be thought about. A design principle that was taken under consideration, “Good design
demands good compromises.” This concluded that in order to make a great design in the user
interface, there needs to be compromises in different parts of the design. Seeing that this
application will not be running at every moment of the initial model then it will not max out any
thread until it is running with ReplicatorG. Once the user has made all of the necessary changes
then the application will close out and release the thread. Compromises make great designs while
keeping the functionality of the program.
NX
The NX 3D modeling suite was used repeatedly in the project both for designing parts for the
project as well as to demonstrate a concept. NX is a comprehensive CAD/CAM package that
supports parameterized modeling and a variety of constraints.
25
The first thing modeled was the extruder and carriage. It was expected that it would need
modification so it made sense to model the parts while waiting for the printer to arrive. NX
helped create an accurate and easily modifiable model thanks to its parameterized modeling
features.
Due to the plasma deposition head still being unavailable by the end of the project, a model of
the maximum space available was generated. After moving the carriage to its maximum
position, the space to the chassis was measured and input into NX. The resulting model was then
printed and will be turned in as a final deliverable.
Two spacers were also made once accurate prints were achievable. The first one was created to
act as a hardware offset for the Z axis to make up for the space taken by the glass plate. At the
beginning of a print, the printer “homes” itself, or zeros the axes by moving towards switches
until activated by pressure. This spacer sits behind the build platform and activates the stop
switch 6 millimeters before it would have hit the build platform, setting the zero point such that
the glass plate is compensated for. The second spacer was used to replace ones that were lost on
the printer. As a plus, if spacers are lost in the future while changing extruder heads, more can
be printed using the printer.
The final model developed in NX was the part used to house the circuit parts for the proof of
concept print. The schematic was laid out in a logical fashion, and then the part was printed.
The firmware’s Z-stop was used to pause the printer at the last of the layers of “traces”, and then
the circuitry was assembled and the print resumed.
Optimizations
While working with the 3D printer, the team discovered that there are many things that can be
done to ensure a better quality print. It is very important to create a good foundation, if the
foundation is good the print is much less likely to fail. If the foundation is messy or begins to
show flaws, the flaws will become worse and the print will ultimately fail.
While having the bed heated helps the plastic stick to the bed, creating a good base, it should be
turned off after a few layers. Leaving the bed on for an entire print will cause the print to begin
to warp at the corners. This warping propagates through the print and creates a piece that is
distorted and undesired. By turning the bed temperature off after a few layers, this is prevented
and the piece comes out much more smoothly. Also, the default bed temperature specified by
ReplicatorG proved to be too high for the PLA plastic that was printed. Setting the bed
temperature slightly lower improved the quality of the first layers that were printed.
26
Another thing that helped the quality of the first layers was to print them at a slower rate than the
rest of the print. The team found that slowing the first 3 layers to 0.6x speed made a sturdy, clean
base. After 3 layers, the speed could be readjusted to 1x speed. The fastest that the printer can
operate while maintaining a good print quality is approximately 1.2x speed.
When printing with two colors of plastic, small overlaps may occur. This happens because even
after the stepper motor stops extruding plastic, the plastic that is still left in the head will melt
through and leak out, causing it to drip onto the part in places where it shouldn’t be. To try and
lessen this effect, there is a feature on the 3D printer called “ditto”. Turning on the ditto function
tells the printer to print the same thing with both heads. This only works if your part is smaller
than the space between the two heads, which is 33mm. The printer will print out excess plastic
with the head not in use. This makes the plastic come out smoother and removes the problem of
cross-contamination. The downside to this method is that it will use twice as much plastic as a
normal print.
Test Circuitry
In order to display the possible future of this project and give proof of concept for multi-material
printing a simple circuit was designed with the intention of embedding it in printed plastic as if it
were a large integrated circuit. Because this circuit was intended just for proof of concept a
simple flashing LED circuit was designed to show that electronic elements were working within
plastic. This was achieved by operating an NE555 timer in A-stable mode with three resistors
and two capacitors. The resistors were chosen at 390KΩ and the capacitor at 1μF to create a
period of one second. However, the 1μF available were electrolytic and were oddly shaped and
may get damaged during the printing process. A standard capacitor was available at .1μF so that
was used and the resistors were bumped up to 4.7MΩ to keep the one second flashing period.
The layout was then created in a single plane to simulate a metal printed layer with the 555 timer
placed in a well created in the plastic. The circuit was simplified by removing the regulating
resistor and capacitor pairing to reduce the complexity in the traces and bring the metal layers
into the single plane. With the number of circuit elements reduced the metals were routed so
there would be no crossing and would reach the resistors and LED placed on the perimeter of the
plastic model. The capacitor is placed within its own well within the plastic to avoid wire
crossing or lengthy leads outside of the plastic model. Rather than using a switch, a well was
created where the wires connected to the VCC and ground of the circuit were exposed and a 33.6 volt CR2023 battery can be inserted or removed to control power. A simple plastic model
was created in Siemens NX after measuring the wire, capacitor and timer sizes. When the model
was printed a z-axis pause was placed at the end of the metal layer and the design team placed
the circuit elements and soldered wires in the empty space in the plastic model. This process took
about two hours and the print was then resumed to finish the test circuit. During the top layer of
the print the extruder nozzle brushed the LED several times and disconnected one of its terminals
27
which had to be re-soldered by melting through the surrounding plastic giving the finished piece
a blemish next to the LED. The final product is a small green block that has a pair of resistors
and LED visible on its side with a small slot on the top for placement of the battery (Figure 12).
The circuit operates correctly with a period of around one second. The success of this circuit
suggests that the multi-material printer could be very useful for simple wire routing or further in
the future, creation of very complex multi-planar circuitry.
Figure 12: Test Circuit open
Chapter 4
Test Data
Due to the nature of our project there is very little quantifiable data that can be considered test
data. There were a series of test prints that took place throughout the semester to ensure the
project objectives were being completed and the software and hardware being utilized was
working properly. Test prints began with calibrating the printing. This required printing 20mm
cubes that were measured for accuracy and observed for smoothness and fill. During the
calibration phase many cubes measured less than 20mm in the 18-19 range and caused several
misprints and calculations were made to ensure the plastic volume was extruding correctly.
These test cubes helped find erroneous entries in the slicer program that were changed and made
the prints much more accurate. There were other prints designed to test the software that the
design team created. These prints were also generic cubes, one set that tested that temperature
controls for the bed and extruders that were used to see if they were being disabled or set
properly by the additional G-code processing program. The multipass functionality was also
tested by observing G-code generations and recognizing path commands being repeated which
will create an additional pass during the printing operation. For proof of concept plastic was
printed on an aluminum plate instead of glass to check for bonding, there was no means for
creating data but partial bonding was observed between the plastic and metal surface. More
28
importantly several tests involved stopping plastic prints to place metal within the model which
is the sponsor’s vision for this project. Initially an aluminum sheet was placed on a paused print
and had the remaining plastic placed overtop and produced a simple connection that was able to
conduct electricity and be tested for current and voltage. Picture of this print can be found
below.
Bonding during this print is inconclusive but the foil did tear at the edge of the plastic and could
not be removed from inside the plastic. Finally a test circuit was built within plastic with a
flashing LED to fully show the potential of the project. The picture of this part can be found
below:
29
Plasma Head Implementation
Unfortunately the plasma deposition head was not ready by the end of the project development
so a 3D model of the maximum area the plasma head can occupy was generated and printed.
This model will be given as a deliverable, both in electronic and physical format. The model has
been tested and accurately represents the maximum space available. The signal into the extruder
was also observed.
The electrical signal operating the extruder is intended to be used for a stepper motor. The
stepper motor takes the signal and when it rotates it pushes filament out of the extruder regulated
the flow of plastic. If the sponsor chooses to make the metal extruder head compatible with this
signal it is important to document. The stepper motor being used is a 17HD4063-20N Hybrid
stepper motor from Moons’ Industries with a JST PHR-6 connector housing (Figure 13). From
probing of the signal and data sheets it appears the signal is a Half-stepping bi-polar 2 phase
stepper motor control signal with sequence model in figure 14 and has an 8 lead configuration
shown in figure 15. The signals are all held high to maintain torque during standby and are on
the order of 40 volts. The oscilloscope probing was unable to reliably trigger on the signals and a
waveform is not available. If the sponsor could make his extruder head operate on this signal his
device would be able to plug and play with the printer. If it turns out that the hardware is not
compatible, the firmware will need to be flashed on the printer to output the necessary signals.
Figure 13: Stepper Motor Connection
Figure 14: Sequence Model
30
Figure 15: Motor Configuration
Proof of Functional design
Hardware:
Once the z-level spacer was installed onto the printer a full calibration was done on the printer
for both the extruders for optimal integration of the new part. Once the calibration was
implemented, we tested the new settings on test prints. The first layer of each test prints is
critical for showing the performance of this spacer and calibration. We printed the first layer of
the test files and paused the print after the first layer. Once the print is paused a caliper was used
to measure the thickness of the first layer. The thickness was within 5% error, then the complete
form was reinitialized and a final Z-level thickness was measured once the print is complete.
The final Z-level thickness was around .2% error from the 3D model.
Software:
After the software was completely developed, the testing for functionality was determined by
using it with the full version of ReplicatorG. The test will include a simulation of the user having
modeled a 3D part and then continues to change the setting using the newly created application.
The first step was to generate the G-code with the correct setting that ReplicatorG offers such as
the type of material, print speed, and any type of support need for the 3D model. Since the Gcode Editor automatically open once ReplicatorG is opened, then the user will have to choose
“Run” and make the necessary changes.
31
Figure 16: Editor with temperature defined settings
The simulation that was chosen to test the functionality was a single head print that only prints
one type of material. This gave a clear understanding as to what the software interface is
supposed to be capable of. As seen in Figure 16, there are a number of predefined settings that
will be made to the G-code. The temperature for the left extruder will be changed and the right
extruder will completely be shut off. The bed/platform temperature is set to 60°C. Once “Apply
Changes” is clicked the changes are made to the Edit.gcode. Testing the loop of the interface was
not complicated. The file Edit.gcode was deleted multiple times to see the G-code Editor produce
another file with the same changes as the user requested. To go further, the Code.gcode was
changed to ensure that the interface made the respective changes to the current file and duplicate
it with the heading “(edited)” to make sure it is marked for future use of the file.
After the confirmation of the loop, the G-code was loaded back into ReplicatorG. Figure 17
shows the changes before and after the G-code Editor application made the changes to the
temperature. It takes both commands and then changes the temperature based on the tool that is
actually in use. This design of the software interface is fully functional.
Figure 17: ReplicatorG displaying the differences in G-code before and after the Editor changes
32
Functionality for the multipass feature needed to be tested and confirmed. The multipass has its
own tab in the user interface. It is designed to initially have multipass turned off. Once turned on,
the user can only select one nozzle to use multipass on and then chose how many times to
traverse over the same line. Shown in Figure 18, the setting for the multipass functionality test is
defined. The right extruder is set to have a double multipass. ReplicatorG assigns the right and
left nozzle to a fix symbol throughout the whole G-code.
Figure 18: Editor with multipass defined setting
The right extruder is referred to as “T0”. After the changes are applied to the G-code, it remodels
exactly how the logic should display it. Referring to Figure 19, notice that there is double the
amount of commands every time the printer switches to the right extruder, “T0”, proving that the
concept of multipass has been working correctly.
Figure 19: G-code showing functionality of multipass before and after
33
Chapter 5
Summary
With the time constraint given on this project, all customer requirements have been
met. However optimizations of the software are recommended for complete implementation of
this printer and controls on external print heads.
The program successfully implemented the options to set temperatures and create a multipass
feature. The printer successfully printed two colors in the same object. The printer successfully
printed over metal. The printer occasionally failed to print correctly, but the causes of problems
were identified and solutions were found. Efforts were made to bring the project as close to
implementing a new extruder head. Physical constraints were determined to ensure a new head
will fit within the printer and electrical signals were recorded to provide a base for controlling a
new head. Software wise everything worked as intended, however currently our software uses
100% of the thread that window’s assign it to. Thus a computer with at least 2 cores and 4
threads are recommended for our programs.
The final cost of the project came to $1128.95, which is less than the extended budget needed to
cover the estimated $1500 cost. The printer cost $949, the biggest expense. Kapton tape was
purchased for the bed, which cost $22.48. The replacement springs for the build platform were
$5.62 and $5.01. A new set screw was purchased to replace the inferior nozzle adjustment
screw, which cost $2.60. A hex tool was purchased for $13.98 and a fan was purchased to cool
the filament for $15.88. Lastly, additional filament was purchased in orders of $22.50, $47.92,
and $43.96, summing to a total of $114.38. We did not need to purchase additional controller or
extruder which greatly reduced the cost from expectations.
All that is left to get the printer creating metal structures is to install the plasma head and finalize
control of it. The plasma head will need to be designed to take input from the square wave used
to drive a stepper motor, since that is the printer’s output to control plastic extrusion.
Additionally, the speed of the head could be implemented in the G-code postprocessor. While
this can be done in ReplicatorG and the print speed should be slowed down for metal printing, it
requires going into the slicer settings, and it would be easier to adjust in the easy-to-use G-code
postprocessor.
Lastly, the algorithm in the G-code postprocessor is very processor intensive. It works properly,
however this is not ideal and a more efficient solution should be implemented.
34
Final Schedule
35
Appendix 1: Technical roles, Responsibilities and Work
Matthew Luzenski:
My technical contribution was to help in metal extruder control and document the electrical
interface at the printer heads so we know the signals which a new proposed head would have to
interact with. The printer extrusion operation is a filament flow that is regulated when forced by
a stepper motor into the heated extruder. The stepper motor was probed and the input signals
were documented in this final report.
My other technical contributions were to test operate the printer which involved help during
calibrations and creating a test circuit to demonstrate the feasibility of metal printing in plastic.
For calibration I helped search through ReplicatorG and the Skeinforge slicer to locate variables
that would change the extrusion amount and where the plastic being was extruded. During test
printing we noticed the test cube was being scaled and this was causing overflow, however
calculations showed the right amount of plastic was being extruded and the printer and firmware
were operating correctly. The issue was corrected by changing two variables, one that removes
the objects perimeter and one that assumes the density of the plastic.
The test circuit mentioned above was designed using a 555 timer to blink a red LED on
breadboard with a 3V 2032 battery before being mapped out so that can be put into plastic. I
created a metal trace layout that simulates metal printing and helped create a model in NX that
would accommodate the timer and traces. The group then printed the plastic model and soldered
the circuit elements outside the model to metal wires laid in the trace paths. The final product is a
fully encased IC that flashes a red LED when the battery is inserted into the plastic. I also had a
secondary role in discussing and making suggestions on how new code was supposed to operate
when issues occurred when interfacing with ReplicatorG.
36
Michael Saybolt:
As far as reports go, I completed or played an equal, and agreed upon role in the following
assignments: project pre-proposal, GANTT chart, voice of customer, FAST diagram, progress
report, the business model assignment (listed as "business canvas" in syllabus?), a progress
report, my application note about calibrating the 3D printer, the design issues assignment, this
paper, and finally the final report which is not finished yet.
I helped prepare and spoke in our team project presentation as well as the team technical lecture.
My technical role in the design of the project included software selection and printer calibration.
I also helped with a function in the G-code postprocessor. The printer calibration involved
numerous test prints and trial and error realizing that parameters have been disabled throughout
the numerous software updates. The result is a lot of time and plastic wasted attempting to adjust
settings that don't actually change anything in the G-code output. Eventually the correct
parameters were located, called
I also learned and made two spacers in NX, as well as provided the team with a delay function
ported to C++ that I wrote in C# for work. This was a crucial part in the software interface used
to hold off the G-code editor program's main logic until the user has generated a G-code file. I
also provided the team with a solution to saggy PLA prints using active cooling with a fan
attached to the carriage with my custom mount and FET soldered to the control board to activate
it, but we decided to go with a desktop fan controlled manually for simplicity.
Lastly I helped babysit the printer during some long prints, including during calibration.
37
Annalin Davis:
My role on this team was primarily on the software side of the project. I was responsible for
creating the code that is the main logic behind working in the new settings for our software. The
settings are to set/remove temperatures and change the ratio of printed layers. This is done by
changing the G-code generated by the slicer software. The code that I wrote was in c++ and
evaluates the old G-code line by line while looking for keywords that signify tool changes or
temperature settings.
I helped to integrate my code with Josh's work in Visual Studio. We had to verify that the logic
would still work inside of the user friendly interface he created. I also helped test the final Editor
program and fixed bugs that became apparent in the process.
Other responsibilities that I shared were: organizing documents so that the partitioning of work
could easily be done, helping identify the constraints and evaluating solutions that would meet
those constraints. I researched possible solutions and organized them according to our projects
design goals. I helped calibrate the printer, produce test prints and evaluate printer performance.
38
Joshua Folks:
My name is Joshua Folks and I am a Computer Engineering major at Michgian State University
and my role on Design Team 11 was to be Project Manager. My initial portion of the technical
work that was stated in the design proposal was to work on the UI development and extruder
speed and movement, calibrating the printer x, y and z levels. The main technical task that I took
on during the semester is the user interface development. Microsoft Visual Studio was used to
create the user interface. Some of the constraints that I had during the design process what to
implement a high level of ease with use and also make it user friendly. The program has the
ability to change the temperature of the extruder heads, both left and right, and the bed
temperature. The user has the option to either turn off the extruder head/bed or set your own
desired temperature for the either one. A feature of the user interface that I created is to turn off
the user input if the respective extruder/bed is turned off. This saves from the confusion as to
whether the temperature is on or set to the values that is inside the input box.
Another feature that the user interface implements is the multi-pass feature. This feature is
catered to the ability to print metal using the same printer. When the plasma head is attached to
the 3D printer the concept is to print a metal-based element where the metal is being placed atom
by atom. The multi-pass is able to go over a certain line more than once. I worked with Annalin
Davis for the logic of this and intertwined it with the user interface.
The GUI has a lot of task that it will complete in milliseconds time. Once the program is opened
I have coded it to not run with ReplicatorG until the user makes it first edit. Once that has
happened then the program will go into a loop that happens every quarter of a second. During
this loop it will check for the original G-code file and then check for an edited G-code file. If it
does not see an edited G-code file then it will proceed to create one. I worked with He Chen to
implement this loop.
39
He Chen:
My technical role on this team is as follows:
1. Create the basic structure/ pseudo of our two program
method (ReplicatorG and our custom G-code Editor)
2. Create the interface with the open source software
ReplicatorG and our custom G-code Editor Software
3. Calibrating the printer and Slicer (Skeinforge)
4. Creating all forms of CAD for the team. From desired
print models to CAD of our current printer head.
In the following section I will expanded upon each of the rules
numbed above.
1. I completed and presented my basic structure of the two program method with the team
around the 20th of March. This is after weeks of trying to figure out how we can
implement logic directly inside ReplicatorG thus eliminating the need for two programs
for altering G-code. It was concluded to be not time efficient for complete integration
with ReplicatorG. The following is record of the first pseudo written on our final design
by me on March 24th.
2. Due to our customer requirement of having a user friendly UI. Alterations must be made
to ReplicatorG source code in order for minimum user interaction with our custom
software. All of the source code for ReplicatorG in appendix III are my work.
3. Due to the nature of ReplicatorG being open sourced. Many settings that are involved in
calibrating the slicer were either not implemented or override elsewhere in the program.
Thus the all the profile settings we discussed in Chapter 3 were found by me through trial
and error by looking at the G-code and print results. This includes: infill perimeter
overlap, overlap removal width over perimeter width, and filament packing density.
4. I took upon the responsibility of using Siemen’s UGS NX to model all the parts required
for this project. This included many calibration parts for calibrating as well as parts for
demonstration such as well the metal embedded in plastic parts.
40
Appendix 2: Literature and Website References
References:
[1] "Objet Connex 3D Printers." Objet Connex Multi-Material 3D Printers. N.p., n.d. Web. 20
Feb. 2015.
<http://www.stratasys.com/3d-printers/design-series/connex-systems>.
[2] "How Does DMLS - Direct Metal Laser Sintering Work?" How Does DMLS. N.p., n.d.
Web. 20 Feb. 2015. <http://gpiprototype.com/blog/how-does-dmls-direct-metal-laser-sinteringwork.html>.
"3d Printers for Sale: ORD Bot Hadron 3D Printer Mechanical Platform Kit | Automation
Technology Inc." Automation Technology Inc RSS. N.p., n.d. Web. 19 Feb. 2015.
"Asterid 1000HB 3D Printer." Asterid 1000HB 3D Printer. N.p., n.d. Web. 19 Feb. 2015.
"Duplicator 4S - Steel ExoFrame – Wanhao USA." Duplicator 4S - Steel ExoFrame –
Wanhao USA. N.p., n.d. Web. 19 Feb. 2015.
"2 phase.17 HDN Hybrid Stepper Motors”. Web. 20 April. 2015.
<http://www.moonsindustries.com/products/Hybrid_Stepper_Motors/HB2P_17HDN/>.
41
Appendix 3: Technical Attachments
MSU Technologies Multi-Material 3D Printer
Quick User Manual and Standard Operation Procedure
4/29/2015
Contents
Introduction
Specifications
Standard Operating Procedure
A. Build a 3D model
B. Generate Gcode for printing
C. Printer Operations
References
42
Introduction
The MSU Technologies multi-material 3D printer is an active project that has the capability of
building plastic 3D models using a Wanhao Duplicator 4S dual-extrusion 3D printer. In the
future the printer will be modified to create embedded metal wiring using a metallic plasma
deposition head. The goal of this document is to give a brief overview of how the printer should
be operated. A standard procedure should be followed in order to decrease the difficulty of use
and limit the time lost to erroneous operation and unfamiliarity. This document will allow the
user to quickly be oriented with the project and conduct prints within specifications.
Printer Specifications
The Wanhao Duplicator 4S used for this project is a stainless steel printer chassis with 3-axis
control for fused deposition modeling (FDM). The printer takes input from a wall socket and
uses 24V DC @ 6.5A. Operation requires .Gcode files created by Replicator G that are read from
USB or SD card. The Wanhao Duplicator 4S has plastic print specifications as follows.
 100µm-340µm plastic layer resolution
 11µm positioning precision in x and y axis
 2.5µm positioning precision in z axis
 22.5×14.5×15 cm maximum print dimensions
 Plastic Extruder Nozzle Diameter .4mm
 Compatible with 1.75mm diameter PLA/ABS filament
Replicator G is the software interface that provides the slicing and code generations that are
necessary for the operation of the 3D printer. Replicator G takes .stl files and allows
manipulation on a virtual build plate. Several options can be selected so that prints are made to
the user’s requirements and the code output to the 3D printer creates a part properly.
Standard Operation Procedure
The standard operation procedure for the MSU Tech printer can be broken down into
three steps. The first step is building a 3D model in a software of choice and producing a file that
can be used by Replicator G and passed on to the printer. The second step is creating Gcode
controls that will be used by the printer. Finally the part can be fabricated by operating the 3D
printer.
43
A. Building a 3D model
3D models for printing must be created in software that produces a .stl output file that can be
read by the slicing software in ReplicatorG. For this project we use Siemens PLM NX 9.0 for
modeling. 3D models must be made so that they will balance on the build plate or have supports
that will keep the part still while printing. For multiple material prints two 3D models must be
made and will later be used together in Replicator G. Make a model for each material and save
both as an independent .stl file. The following are required creating a proper STL file:

STL are unitless. Since ReplicatorG uses MM as units, use MM in the respected 3D
modeling software.

ReplicatorG will use the XY plane of the CAD software as the lowest point of the print.
Thus hovering parts will not be printed on the built plate.
B. Creating Gcode for printer control
Open ReplicatorG and click the file menu and open the .stl in the extruder for the material you
want to build in. Moving, scaling, and rotating STL file models are available in ReplicatorG UI.
For extruding in two materials go to the Gcode menu and select Merge .stl for DualExtrusion,
open the .stl files in their appropriate extruder location. Due to the precise nature of coordinating
two extruders control at once, STL should only be edited in their respected CAD software to
ensure proper alignment of the two separate STL files.
Figure 2 Opening multiple .stl
44
For both single and dual extrusion a G-code dialogue box will show up for the user to select the
desired settings. For dual extrusion case, dialogue will appear for separate controls of each head.
The following are the settings and the descriptions for the dialogue box.





Object Infill (%): this option determines how much plastic will fill the volume of your
build.
Layer Height: This is the plastic layer resolution.
Number of shells: This is the number of passes that create the outer part of your build.
Feedrate: Speed of Extrusion.
Travel Feedrate: Speed of carriage while not extruding.
Figure 3 Generate Gcode dialogue box
Once the desired settings are inputted, click generate on the bottom.
Now select the updated settings from the Gcode Editor menu
 Temperature Control: Extruder and bed temperatures can be disabled or determined here.
 Multipass: This will allow you to repeat tool paths to create duplicate layers.
45
Figure 4 Gcode Post-processor window
When settings have been verified, the user must update the G-Code file that is currently loaded
onto ReplicatorG with our edited file. To do this, simple push CTRL+G on ReplicatorG window
or click Files and then “Update G-Code”.
Figure 6 File Menu
Next, ensure you have the printer SD card inserted in your computer and click the Build File for
use with SD card. Save the file as .x3g in the root folder and remove the SD card and begin
printer operation
C. Printer Operation
Gently insert the SD card into the receiver slot located on the inside on the printer behind the
LCD screen on the right side. Once inserted select >Build from SD in the main menu, find your
file from the root folder of the SD card and begin the print. At this point the printer will begin the
build or preheat to your selected bed temperature. Wait for the build to finish and plastic to cool
before removing the finished part from the build plate. The print can also be canceled early at
any point during the build.
Build Plate Basics
46
The build plate is the metal sheet that a part is printed on. It should always be covered by a
yellow kapton sheet the helps plastic adhere to the build plate. If the kapton sheet is sufficiently
dirtied or torn carefully remove and replace the sheet with a new one. A glass plate can be placed
on top of the build plate if desired.
The build plate can be preheated before prints. Typical operation requires a temperature of 110C
for ABS plastic and 50C for PLA. Typical extrusion temperatures are around 220C.
Preheating
To preheat select >Preheat from the main menu and select which elements you want to heat.and
select >Start Preheating. To disable the heaters return to the >Preheat menu and select >Turn
Heaters Off.
Utilities
Build Plate Leveling
In order to ensure proper adhesion to the build plate and a good print, the build plate should be
occasionally checked for leveling. The build plate has four knobs with springs that move the
plate up and down on the mount. The build plate can be leveled by selecting >Level Build Plate
in the >Utilities menu on the LCD screen of the Duplicator 4S.
1. To begin, tighten or loosen the knobs to get the plate in a position that it appears level.
2. Then bring the build plate up to the extruder nozzles to a point where a piece of paper can
slide between with some friction.
3. Move the extruder around to check that the paper slides with some friction across the
entire build.
4. The build plate will be level and you can end the leveling program.
Loading Plastic Filament
The Duplicator 4S is compatible with both PLA and ABS plastic filaments. Following are the
procedures for loading and removing filament from the plastic extruder.
Loading filament
1. For loading, begin by detach the filament sleeve from the top of the extruder.
2. Guide the filament through the protective sleeve and above the extruder.
3. Start heating the extruder using >Load (L/R) >Filament Loading in the >Utilities LCD
menu.
4. When the extrusion head reaches 220 C hit okay and push the filament into the extruder.
47
5. Wait until plastic begins extruding from the nozzle.
6. End the extrusion and remove the excess extruded plastic.
7. Put the sleeve back in the opening on top of the extruder to finish loading filament.
Removing filament
1. To remove filament from the extruder, begin by detaching the protective sleeve.
2. Start heating the extruder using >Unload (L/R) >Filament Loading in the >Utilities LCD
menu.
3. When the extrusion head reaches 220 C remove the filament and any excess plastic that
was extruded from the nozzle.
Home Axes
This setting will bring the build plate up to the highest z level by detecting the moving platform
with the button found in the back of the printer. This will also bring the extruder carriage to its
home position in the back right of the printer.
Preheat settings
In this utility you can change the temperature of the left, right extruders, and the build platform
in Celsius.
Ditto Printing
Ditto printing will cause both extruders to receive the same signal and create the same object side
by side (given the object is smaller than the distance between the nozzles). This setting can be
enabled in >General Settings in >Utilities
Jog Mode
Enabling jog mode will allow you to control the extruder carriage with the buttons. Use left/right
to change axis and up/down to move within the selected axis.
Enable/Disable Steppers
Enabling the steppers will lock the stepper motors with a high signal. Disabling the steppers will
allow the operator to slide the carriage and platform by hand.
48
Printer Operation During Print
During your print the LCD screen will show the percentage completion and temperatures of the
printer. Hitting the center button during a print will bring up an in-print operations menu.
Cancel Print
Hitting this will immediately end the print and leave the current file.
Pause
This is a manual pause. The extruder head will vacate the nozzle and suspend printing at the next
line of gcode allowing for inspection and interaction with the part.
Pause at Zpos
An automated pause feature. This will pause the print when it finishes the layer at the specified z
position. Use up and down to change the value and left to cancel.
Change Speed
After entering this option use up or down to change the percent speed of the print by 5%
increments.
Change Temperature
This option allows you to modify the extruder temperatures.
Print Statistics
A menu that will show the current print time, estimated time remaining, filament odometer, and
current z position.
References
More in depth printer instructions and illustrations can be found in the Duplicator 4/4X/4s
Desktop 3D Printer User Manual. http://wanhao3dprinter.com/main.aspx?id=2013020021
http://replicat.org/usage
49
Test Circuit Schematic
50
Source Code
1. Due to our customer requirement of having a user friendly UI. Alterations must be made
to ReplicatorG source code in order for minimum user interaction with our custom
software. The following changes were made by me in ReplicatorG source code:
 The following function is used to open up our custom software when it’s called.
This uses a basic function of C to run commands directly into command prompt
of a windows machine. Thus this simulates the operation of opening up command
prompt to the root folder of the program and then launching Editor.exe.

The following function is only called when a new code is being generated. It
checks to see if Edit.gcode exist and deletes it if it does. This is due to the need to
delete old G-code once a new G-code is generated. Once the file is deleted it
copies the generated code to Code.gcode. Once this file is created our custom Gcode Editor will edit it and create Edit.gcode.

The following implements the update logic to our G-code. Once Edit.gcode is
created by our printer. An option is implemented in main menu File > “Update
G-Code” or CTRL + G to update the G-code on ReplicatorG’s UI to the edited
51
file. The following also contains the logic for when a new file is opened. Once a
new file is opened, Code.gcode and Edit.gcode is deleted and the loaded file is
copied onto Code.gcode for our editor to edit. Lastly this following code contains
the logic to close out Editor.exe once ReplicatorG is closed.
52
53

The following Code was implemented such that every time a message is updated in
the dialog box in ReplicatorG, it checks to see if our program is running. If not it will
open our program encase of accidental closure.

The following function is called whenever a .gcode file is saved. This function will
save the file to the desired location as well as copy the file to Code.gcode for our
editor to edit.
54
2. This next piece of code is the complete logic for the user interface. This is showing how
input text is being disabled when the check box is changed.
55

This last pieces of code after the function “applyChanges_Clicked”, this shows the
logic that the user interface completes as it set the settings of the printer to the
variables in the code. This section has been all created from scratch.
3. This next piece of code that is on the following four pages describes the logic to actually
implement the Temperature changes and the Multipass changes to the G-code. This code
is commented very thoroughly.
56
57
58
59
4. The following code that is displayed on the next two pages shows the while loop that the
user interface enters after the changes are made to the G-code. It shows the process that it
goes through in order to check for the necessary files and to make the necessary files up
to standard with the user’s alterations. This code is also thoroughly commented.
60
61
62