11. MACHINE BUILDING

Index

  • Assignment
  • Continuation
  • Making the electromagnet
  • Working with gestalt nodes
  • Problems and solutions
  • Summary

A. Assignment

  • Build a personal site describing you and your final project.
  • Plan and sketch a potential semester project and add it to your website.
  • Upload it to the class archive. Work through a git tutorial.

B. Continuation

In this week we are continuing our work on the FabARM. We are automating the operations which we did mechanically in the 9th week. This is the final thing we made last week.

Build from 9th week
This week we are planning to move the arm in a linear path and make it do stuffs like pick and place, Basic drawing etc. I was assigned the task to make an electromagnet for the pick and place mechanism.
Link to the group page

c. Making of the electromagnet

The raw materials i could find where a nut and bolt, and insulated copper wire. I know that a current carrying conductor will create magnetic field around it . Also that we can create an electromagnet by winding such insulated copper wire on a magnetic material like the cut and bolt i am using.I decided to try that out.

Raw materials

I used the drill to wind the copper wire on the bolt.


Winding the wire with the hand drill
Finally i have my electromagnet.

Electromagnet


Electromagnet in action

We have everything in place and its time to make a path for the pick and move motion of the arm. We used potentiometers to control each servo. I had to find the position of the servos in each point in the motion of the arm. I adjusted each potentiometers and got the points and found the positions of the servos. These points where used to automate the motion. The code is attached below.

arm.ino
pop-uptext
  1. //Including the servo library
  2. #include <Servo.h>
  4. //define the servos
  5. Servo servo1; 
  6. Servo servo2;
  7. Servo serco3;
  9. int 1 = 100;
  10. char inByte;
  11. int a =1;
  13. //variables identified through calibration with potentiometer
  14. int valPot1[]={100,100,100,100,102,102,102,118,128,138,145,152,152,157,157,157,157,157,157,157};
  15. int valPot2[]={139,137,113,88,71,71,71,71,71,71,71,71,71,71,88,100,108,118,117,118};
  16. int valPot3[]={45,45,45,45,45,86,76,76,76,76,76,76,76,76,76,76,76,56,48,45};
  17. void setup()
  18. {
  19.     //Initializing the serial
  20.     Serial.begin(9600);
  21.     //attach the servos to the PWM pins
  22.     servo1.attach(9);
  23.     //setting the start position
  24.     servo1.write(150);
  25.     servo2.attach(10);
  26.     servo2.write(90);
  27.     servo3.attach(11);
  28.     servo3.write(90);
  29. }
  31. void loop()
  32. {
  33.     for(int i=1; i<=19; i++)
  34.     {
  35.         //setting the servo positon to the found value
  36.         servo1.write(valPot1[i]);
  37.         servo2.write(valPot2[i]);
  38.         servo3.write(valPot3[i]);
  39.         delay(500);
  40.     }
  41.     for(int i=19; i>=1; i--)
  42.     {
  43.         servo1.write(valPot1[i]);
  44.         servo2.write(valPot2[i]);
  45.         servo3.write(valPot3[i]);
  46.         delay(500);
  47.     }
  48. }
source code

Finally we implemented the pick and place mechanism with the electromagnet.

Pick and place

d. Working with Gestalt nodes

As we made the arm to do the pick and place, the next part is to move ahead with the linear guide rail. Initially we where planning to implement a rack and penion mechanism for the linear guide rail. But it didn't succeed due to limited power of the stepper we where using and due to excessive friction in t contacting parts in the rail mechanism. The next option was to try the steppers in the mtm kit. This kit comes with steppers with threaded rods and could be used to move the arm in a single axis. We could fix the stepper to the arm platform without any design change. Finally we did that and then it was time to code the motion. You can get the full source files from github. A detailed documentation on how to get started with gestalt is available here. We followed the link to gather a working knowledge and modified the sample code provided to suite our requirement. The modified code is given below. The original file can be found in examples >> machines >> htmaa folder.

single_node.py
pop-uptext
  1. # Forked from DFUnitVM Oct 2013
  2. # set portname
  3. # set location of hex file for bootloader
  4. #
  6. #------IMPORTS-------
  7. from gestalt import nodes
  8. from gestalt import interfaces
  9. from gestalt import machines
  10. from gestalt import functions
  11. from gestalt.machines import elements
  12. from gestalt.machines import kinematics
  13. from gestalt.machines import state
  14. from gestalt.utilities import notice
  15. from gestalt.publish import rpc    #remote procedure call dispatcher
  16. import time
  17. import io
  20. #------VIRTUAL MACHINE------
  21. class virtualMachine(machines.virtualMachine):
  22.     
  23.     def initInterfaces(self):
  24.         if self.providedInterface: self.fabnet = self.providedInterface        #providedInterface is defined in the virtualMachine class.
  25.         else: self.fabnet = interfaces.gestaltInterface('FABNET', interfaces.serialInterface(baudRate = 115200, interfaceType = 'ftdi', portName = '/dev/ttyUSB0'))
  26.         
  27.     def initControllers(self):
  28.         self.xAxisNode = nodes.networkedGestaltNode('X Axis', self.fabnet, filename = '086-005a.py', persistence = self.persistence)
  29.         self.xNode = nodes.compoundNode(self.xAxisNode)
  31.     def initCoordinates(self):
  32.         self.position = state.coordinate(['mm'])
  33.     
  34.     def initKinematics(self):
  35.         self.xAxis = elements.elementChain.forward([elements.microstep.forward(4), elements.stepper.forward(1.8), elements.leadscrew.forward(6.096), elements.invert.forward(True)])
  36.         
  37.         self.stageKinematics = kinematics.direct(1)    #direct drive on all axes
  38.     
  39.     def initFunctions(self):
  40.         self.move = functions.move(virtualMachine = self, virtualNode = self.xNode, axes = [self.xAxis], kinematics = self.stageKinematics, machinePosition = self.position,planner = 'null')
  41.         self.jog = functions.jog(self.move)    #an incremental wrapper for the move function
  42.         pass
  43.         
  44.     def initLast(self):
  45. #        self.machineControl.setMotorCurrents(aCurrent = 0.8, bCurrent = 0.8, cCurrent = 0.8)
  46. #        self.xyzNode.setVelocityRequest(0)    #clear velocity on nodes. Eventually this will be put in the motion planner on initialization to match state.
  47.         pass
  48.     
  49.     def publish(self):
  50. #        self.publisher.addNodes(self.machineControl)
  51.         pass
  52.     
  53.     def getPosition(self):
  54.         return {'position':self.position.future()}
  55.     
  56.     def setPosition(self, position  = [None]):
  57.         self.position.future.set(position)
  59.     def setSpindleSpeed(self, speedFraction):
  60. #        self.machineControl.pwmRequest(speedFraction)
  61.         pass
  63. #------IF RUN DIRECTLY FROM TERMINAL------
  64. if __name__ == '__main__':
  65.     stage = virtualMachine(persistenceFile = "test.vmp")
  66.     #stage.xNode.loadProgram('../../../086-005/086-005a.hex')
  67.     #stage.xNode.setMotorCurrent(1)
  69.     stage.xNode.setVelocityRequest(8)    
  70.     
  71.     #f = open('path.csv','r')
  72.     #supercoords = []
  73.     #for line in f.readlines():
  74.     #    supernum = float(line)
  75.     #    supercoords.append([supernum])
  77.     #stepper moves given as array
  78.     supercoords = [[100],[200],[100],[0],[100],[200],[100],[0],[100],[200],[100],[0],[100],[200],[100],[0]]
  80.     for coords in supercoords:
  81.         stage.move(coords, 0)
  82.         status = stage.xAxisNode.spinStatusRequest()
  83.         while status['stepsRemaining'] > 0:
  84.             time.sleep(0.001)
  85.             status = stage.xAxisNode.spinStatusRequest()    
  86.     

python source code


Linear motion of the arm connected to the stepper

e. Problems faced and their solutions

  1. The guide rail we build was not working due to excessive friction. We tried to use teflon tape on it, but that actually increased the friction. Due to the friction problem we had to abandon the initial guide rail design and had to proceed with using a stepper from the MTM kit. You can see this is the demo videos.
  2. The electromagnet which we made was drawing much current that the arduino can provide. The arduino should draw only around 50 milli amphs of current if more current is drawn through it , the circuitry gets damaged and the chip get bricked. So we had to use an external power source for it using a 5v relay controlled by the arduino, this fixed the issue.
  3. Getting started was quite tricky at first due to the serial port issue. The serial port was found to change between subsequent runs so initially we could'nt get the nodes running. Later it was found that the issue was with loose contact.
  4. Another issue which we found with the gestalt is that it often the node boards take a long time to respond, so we hav to keep waiting for quit sometime to the see the difference after even a minor code change.

f. Summary

  • Together we automated the fabarm.

Creative Commons License
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License.