Mechanical Design, Machine Design
Week 14
Review
This week’s assignment consists to assembly a cnc machine based on the “CardBoard CNC machine” from James Coleman and Nadya Peek. As it was a group assignment we (Daniel Asprilla, Jorge Torres and I) have to plan the functions of each one. At the beginning we define a “global functions” were I had to take pictures, videos and document the whole process.
For the machine we define 3 fundamental tasks. The first one corresponds principally to Daniel and it consisted in download, fix, draw and re make the 3d models and the cutting files for the machine. The second task was to coordinate the laser cut and the assembly of the machine; that one was developed by Jorge. The third and final consisted to make all the electronic production (the Fabnet), connect everything correctly and program the machine to make something. That was my individual contribution with the help from a physic student (Sebastian Ocampo). I have to admit that I don’t have enough experience programing but I was determined to make the machine works and I made it. I also was involved in the whole process of the machine development “coordinating” and working so that everything went on time and in the right way.
3D MODELS AND DIGITAL PRODUCTION
Downloading Original files
The "fab team" began this adventure, downloading the original files of the cardboard CNC in order to fabricate machine. but, we quickly saw some initial errors in the digital models, that affect in somehow the prototype process.
First Adjustments
We checked the cut vectors in relationship with the original downloaded models , and in this case we also found some errors as double lines, and open vectors (nonoptimal for the laser cutting process), for this reason we did the first modifications in the digital files.
Cardboard Machine Redesign
The material thickness didn't work well for us; we realized that there was "problems" with the original model (at this time we don't know if we have the correct files). The cardboard prototype gave us serious problems assembling it, for that reason we decided modeling our digital prototype... of course based in the original downloaded digital model. Redrawing the machine we understood much more the systems.
Machine Framework
Having in mind all the previous "inconvenients", and thinking on how to improve our prototype, we designed a framework in MDF-RH/15 mm (leftover fab-material) for stiffening the CNC machine.
Bottom of the Model
The picture above shows the bottom part of the digital model.
Cutting Files
The picture above shows the bottom part of the digital model.
Further Improvements of the Machine.
Although the cardboard machine "worked" we were not happy with the result. There was a few problems that we could solve with a new material. Again, we decided to make a new CNC in a rigid material, (again with left overs of the fab lab process). The material chosen was MDF of 5 mm. We made again the files based on the original downloaded model.
MDF Machine details.
Machine parts and systems.
"Pencil Case"
Also we designed a the pencil case, because we decided that our machine will a plotter prototype.
MDF machine cutting Files.
This are the digital files "vectors" for the cut process in the shopbot machine.
FROM ASSEMBLY TO IMPROVEMENTS
Description
The fab machine was an easy cnc card board machine that was composed by two or three inter sliding boxes. Our first work was to download the files provided by fab academy, put them to the laser cutting and proceed to assembly. In the first instance we think that all files were correct but it wasn't like that: the assembly process explained to us.
Assembly
Two simply errors derivate in difficults to arm the developed forms: one, an inverted position of the endless screw holes, and, some duplicate lines and inappropriate layers for marking lines. So the confussión was rapidly evaluate and fixed, where perhaps instruct us for a new refined process with the next attempt was neccesary a basic programation that was covered more or less the next steps:.
- Drawing files download
- Card board printing
- Assembling parts
- Programming files download
- Performance testing
- Evaluation
This construction planning was necessary to do at least for three times before a good result.
Adjustements
The principal adjusts consist specially in re-draw and correct again an actualized cutting file that puts in order orientations and marking and cutting lines. This new process gave us an succesfully new cardboard supports that we can to assembly and test completelly once a new.
Problems
Yet despite what has been achieved, new fails was detected, inner there: Because it was chosen the two axis x and y configuration as a first setting was discovered that the weight of the object itself in some box support will influence the correct balance among them. The last influence in the correct and firmly assembly of the cardboard flanges to ensure the moving boxes to travel without tiling. thats situation allow evaluate that it needed a guide and supporting frame for guarantee the firmly contention of first axis and the zero friction on second axis sliding. With this frame we needed to define a goal functional to use the new cnc machine, that we desired was simply and usefull: a free pen to plot plans and designs. To draw with a common pencil we need an correct distance from between movil axis and the draw canvas, and a firmly and easy pen trapping system.
Improvements
The second attempt in the armed take conclussión in a possible original machine simplify that allow to do it with a fewer parts and with best firmness between sliding boxes. In the same way the revision of the original material as cardboard vs plywood, where this last one allows ensured kerf's unions vs uncertained card board folding specially talking about commented tilting. Additionally to the guide boxes the pen support was improved too; was added a kerf and skrewable base platform and a flexible ends with a final graduable fixing ring to ensure verticality. The final product it was revealed. You can see too.
ELECTRONICS PRODUCTION AND MODULES PROGRAMMING.
FabNet
We start by downloading the eagle files to make the FABNET. The FabNet is a multi-drop network, meaning that multiple modules (a.k.a. nodes) share a single set of communication wires. Signaling is differential based on the RS-485 specification. Each node is assigned a four-byte IP address which uniquely identifies it over the network. To make the board we need the following materials:
(1) Eight pin connector, (1) Four pin connector, 2 resistors (value 600ohm) and (1) six pin connector. We milled and soldered the boards with the files provided.
Once the FabNet was ready we follow by connecting the boards following the images provided in Shawn’s tutorial.
Connections
This tutorial was pretty clear in order to connect the “gestalt nodes”. For our machine we have 2 nodes. The communication between the computer and the nodes is done in series, that means that you can add as many nodes as you want following the configuration provided in the image above.
With everything connected we were ready to make the first test of the nodes.
Programming
We follow the next tutorial to program the nodes. wxGestalt is a IDE for controlling Gestalt nodes in Python. The IDE lets you configure the machine, connect to it, and create a GUI for controlling it.
Installing wxGestalt
Most likely wxGestalt won't have any packaged installer for a while. For the moment, you should jump in its development directly! wxGestalt uses at the moment Ilan Moyer's Gestalt, installed as a Git submodule. So, you will have to install it in this way:
- >git clone https://github.com/openp2pdesign/wxGestalt.git
- >cd wxGestalt
- >git submodule update --init gestalt
Git will then dowload the Gestalt library inside the wxGestalt folder. You then have to install the dependencies for wxGestalt:
- >wxPython: check for your OS
- >pip install PySerial
- >pip install unidecode
- >pip install jsonpickle
With everything installed it was time to make the first test. We modified the “xy_plotter.py” file and the next video shows the result.
FAB UNAL MACHINE.
As you can see our machine works well, we draw on it a square and star. The star can be find code bellow.
Code
# Fablab Unal Medellin
# moves get set in Main
# usb port needs to be set in initInterfaces
# Star drawing based in Nadya Peek code
#------IMPORTS-------
from pygestalt import nodes
from pygestalt import interfaces
from pygestalt import machines
from pygestalt import functions
from pygestalt.machines import elements
from pygestalt.machines import kinematics
from pygestalt.machines import state
from pygestalt.utilities import notice
from pygestalt.publish import rpc #remote procedure call dispatcher
from sys import argv
import time
import io
#------VIRTUAL MACHINE------
class virtualMachine(machines.virtualMachine):
def initInterfaces(self):
if self.providedInterface: self.fabnet = self.providedInterface #providedInterface is defined in the
virtualMachine class.
else: self.fabnet = interfaces.gestaltInterface('FABNET', interfaces.serialInterface
(baudRate = 115200,
interfaceType = 'ftdi', portName = '/dev/ttyUSB0'))
def initControllers(self):
self.xAxisNode =
nodes.networkedGestaltNode('X Axis', self.fabnet, filename = '086-005a.py',
persistence = self.persistence)
self.yAxisNode =
nodes.networkedGestaltNode('Y Axis', self.fabnet, filename = '086-005a.py',
persistence = self.persistence)
self.xyNode = nodes.compoundNode(self.xAxisNode, self.yAxisNode)
def initCoordinates(self):
self.position = state.coordinate(['mm', 'mm'])
def initKinematics(self):
self.xAxis = elements.elementChain.forward([elements.microstep.forward(4),
elements.stepper.forward(1.8),
elements.leadscrew.forward(8), elements.invert.forward(True)])
self.yAxis = elements.elementChain.forward([elements.microstep.forward(4),
elements.stepper.forward(1.8),
elements.leadscrew.forward(8), elements.invert.forward(False)])
self.stageKinematics = kinematics.direct(2) #direct drive on all axes
def initFunctions(self):
self.move = functions.move(virtualMachine = self, virtualNode = self.xyNode,
axes = [self.xAxis, self.yAxis],
kinematics = self.stageKinematics, machinePosition = self.position,planner = 'null')
self.jog = functions.jog(self.move) #an incremental wrapper for the move function
pass
def initLast(self):
#self.machineControl.setMotorCurrents(aCurrent = 0.8, bCurrent = 0.8, cCurrent = 0.8)
#self.xNode.setVelocityRequest(0) #clear velocity on nodes.
Eventually this will be put in the motion planner
on initialization to match state.
pass
def publish(self):
#self.publisher.addNodes(self.machineControl)
pass
def getPosition(self):
return {'position':self.position.future()}
def setPosition(self, position = [None]):
self.position.future.set(position)
def setSpindleSpeed(self, speedFraction):
#self.machineControl.pwmRequest(speedFraction)
pass
#------IF RUN DIRECTLY FROM TERMINAL------
if __name__ == '__main__':
# The persistence file remembers the node you set. It'll generate the first time you run the
# file. If you are hooking up a new node, delete the previous persistence file.
stages = virtualMachine(persistenceFile = "test.vmp")
# You can load a new program onto the nodes if you are so inclined. This is currently set to
# the path to the 086-005 repository on Nadya's machine.
#stages.xyNode.loadProgram('../../../086-005/086-005a.hex')
# This is a widget for setting the potentiometer to set the motor current limit on the nodes.
# The A4982 has max 2A of current, running the widget will interactively help you set.
#stages.xyNode.setMotorCurrent(0.7)
# This is for how fast the
stages.xyNode.setVelocityRequest(8)
# Some random moves to test with
moves = [[-12, 0.0],[-24, 24],[0.0,12],[24,24],[12,0.0],[24, -24],[0, -12],[-24, -24], [-12, 0.0]]
# Move!
for move in moves:
stages.move(move, 0)
status = stages.xAxisNode.spinStatusRequest()
# This checks to see if the move is done.
while status['stepsRemaining'] > 0:
time.sleep(0.001)
status = stages.xAxisNode.spinStatusRequest()