Machine design

Over View of Assignments

What is Machine Design ?

Machine Design is one of the important branches of Engineering Design. To understand what exactly machine design or mechanical design is let us consider the example of the gear box of the car. The gear box transmits the motion and the power of the engine to the wheels of the vehicle. The gearbox comprises group of gears which are subjected to not only motion but also the load of the vehicle. For the gears to run at desired speeds and take desired loads it is important that they should be designed. During designing various calculations are performed considering desired speeds and loads and finally the gear of particular material and specific dimensions that can take all loads and that can be manufactured at least possible cost giving optimum performance is designed. In similar fashion all the components of the car, including engine, have to be designed so that they optimally meet all the functional requirements at lowest possible cost. This whole process of designing is called as machine design or mechanical design.

Read More

Work Assigned

Link to Group Project Page

The FabArm we build on Mechanical Design week had some missing components and some fixtures also broke. So we decided to redo it once again ,I have helped to build the final model of the Machine,The most of the designing and testing was done in the week9. but this week we had to make couple of flange shafts to hold up the fab arm. This part was missing when we build the fab arm first time, that is what we did this week. We took apart a printer for a Aluminum Alloy Rod. We cut the rod for our specific need.

Cutting the Alumium Rod

Ajith and Ganadev also helped me initally and they left after some to work on the other work assigned.

Assembly of the Fab Arm

After this I worked on the GUI based on kivy along with ganadev and have used the sample code from Gestalt library to get started and understand it

pop-uptext
  1. from kivy.uix.popup import Popup
  2. from kivy.app import App
  3. from kivy.uix.gridlayout import GridLayout
  4. from kivy.uix.label import Label
  5. from kivy.uix.textinput import TextInput
  6. from kivy.uix.button import Button
  7. from kivy.uix.boxlayout import BoxLayout
  8. from kivy.uix.stacklayout import StackLayout
  9. from kivy.uix.slider import Slider
  10. from kivy.config import Config
  12. Config.set('modules', 'serial', '')
  17. # Forked from DFUnitVM Oct 2013
  18. # set portname
  19. # set location of hex file for bootloader
  20. #
  22. #------IMPORTS-------
  23. from pygestalt import nodes
  24. from pygestalt import interfaces
  25. from pygestalt import machines
  26. from pygestalt import functions
  27. from pygestalt.machines import elements
  28. from pygestalt.machines import kinematics
  29. from pygestalt.machines import state
  30. from pygestalt.utilities import notice
  31. from pygestalt.publish import rpc   #remote procedure call dispatcher
  32. import time
  33. import io
  34. import threading
  35. import serial
  38. #------VIRTUAL MACHINE------
  39. class virtualMachine(machines.virtualMachine):
  40.     
  41.     def initInterfaces(self):
  42.         if self.providedInterface: self.fabnet = self.providedInterface     #providedInterface is defined in the virtualMachine class.
  43.         else: self.fabnet = interfaces.gestaltInterface('FABNET', interfaces.serialInterface(baudRate = 115200, interfaceType = 'ftdi', portName = '/dev/tty.usbserial-FT0METG6'))
  44.         
  45.     def initControllers(self):
  46.         self.xAxisNode = nodes.networkedGestaltNode('X Axis', self.fabnet, filename = '086-005a.py', persistence = self.persistence)
  47.         self.xNode = nodes.compoundNode(self.xAxisNode)
  49.     def initCoordinates(self):
  50.         self.position = state.coordinate(['mm'])
  51.     
  52.     def initKinematics(self):
  53.         self.xAxis = elements.elementChain.forward([elements.microstep.forward(4), elements.stepper.forward(1.8), elements.leadscrew.forward(6.096), elements.invert.forward(True)])
  54.         
  55.         self.stageKinematics = kinematics.direct(1) #direct drive on all axes
  56.     
  57.     def initFunctions(self):
  58.         self.move = functions.move(virtualMachine = self, virtualNode = self.xNode, axes = [self.xAxis], kinematics = self.stageKinematics, machinePosition = self.position,planner = 'null')
  59.         self.jog = functions.jog(self.move) #an incremental wrapper for the move function
  60.         pass
  61.         
  62.     def initLast(self):
  63. #       self.machineControl.setMotorCurrents(aCurrent = 0.8, bCurrent = 0.8, cCurrent = 0.8)
  64. #       self.xyzNode.setVelocityRequest(0)  #clear velocity on nodes. Eventually this will be put in the motion planner on initialization to match state.
  65.         pass
  66.     
  67.     def publish(self):
  68. #       self.publisher.addNodes(self.machineControl)
  69.         pass
  70.     
  71.     def getPosition(self):
  72.         return {'position':self.position.future()}
  73.     
  74.     def setPosition(self, position  = [None]):
  75.         self.position.future.set(position)
  77.     def setSpindleSpeed(self, speedFraction):
  78. #       self.machineControl.pwmRequest(speedFraction)
  79.         pass
  82. class FabControl(GridLayout):
  83.     def __init__(self, **kwargs):
  84.         super(FabControl, self).__init__(**kwargs)
  85.         self.cols = 3
  86.         self.row = 3
  88.         global serialcom, tempmotor1, tempmotor2, tempmotor3
  89.         tempmotor1 = 120
  90.         tempmotor2 = 90
  91.         tempmotor3 = 90
  93.         serialcom = serial.Serial()
  94.         serialcom.braudrate = 115200
  95.         serialcom.port = "/dev/tty.usbmodem1421"
  96.         serialcom.open()
  98.         
  101.         self.add_widget(Label(text='Motor1  [ 0 to 120 ] '))
  103.         self.motor1 = Slider(min=-30, max=120, value=120)
  104.         self.motor1.bind(value=self.Motor1Change)
  105.         self.add_widget(self.motor1)
  107.         self.motor1value = Label(text=str(self.motor1.value))
  108.         self.add_widget(self.motor1value)
  111.         self.add_widget(Label(text='Motor2  [ 0 to 180 ] '))
  113.         self.motor2 = Slider(min=0, max=180, value=90)
  114.         self.motor2.bind(value=self.Motor2Change)
  115.         self.add_widget(self.motor2)
  117.         self.motor2value = Label(text=str(self.motor2.value))
  118.         self.add_widget(self.motor2value)
  121.         self.add_widget(Label(text='Motor3  [ 45 to 130 ] '))
  123.         self.motor3 = Slider(min=45, max=130, value=90)
  124.         self.motor3.bind(value=self.Motor3Change)
  125.         self.add_widget(self.motor3)
  127.         self.motor3value = Label(text=str(self.motor3.value))
  128.         self.add_widget(self.motor3value)
  131.         self.add_widget(Label(text='Motor4  [ -100 to 100 ] '))
  133.         self.motor4 = Slider(min=-100, max=100, value=0)
  134.         self.motor4.bind(value=self.Motor4Change)
  135.         self.add_widget(self.motor4)
  137.         self.motor4value = Label(text=str(self.motor4.value))
  138.         self.add_widget(self.motor4value)
  141.         self.move = Button(text="Move")
  142.         self.add_widget(self.move)
  143.         self.move.bind(on_press=self.initiatemove)
  145.         self.startrec = Button(text="Start Record")
  146.         self.add_widget(self.startrec)
  148.         self.stoprec = Button(text="Stop Record")
  149.         self.add_widget(self.stoprec)
  151.         self.play = Button(text="Play")
  152.         self.add_widget(self.play)
  154.     def Motor4Change(self, instance, value):
  155.         self.motor4value.text = str(value)
  157.     def Motor1Change(self, instance, value):
  158.         self.motor1value.text = str(value)
  159.         threading.Thread(target=self.movemotor1).start()
  161.     def Motor2Change(self, instance, value):
  162.         self.motor2value.text = str(value)
  163.         threading.Thread(target=self.movemotor2).start()
  165.     def Motor3Change(self, instance, value):
  166.         self.motor3value.text = str(value)
  167.         threading.Thread(target=self.movemotor3).start()
  169.     def initiatemove(self,instance):
  170.         # time.sleep(5)
  171.         threading.Thread(target=self.movemotor4).start()
  172.         threading.Thread(target=self.movemotor1).start()
  173.         threading.Thread(target=self.movemotor2).start()
  174.         threading.Thread(target=self.movemotor3).start()
  176.     def movemotor4(self):
  177.         print "movemotor4 called"
  178.         global stage
  179.         # print stage
  180.         # print self.motor4.value
  181.         # print self.motor1.value
  182.         # print self.motor2.value
  183.         # print self.motor3.value
  185.         # 
  186.         movemotor4 = int(self.motor4.value)
  188.         supercoords = [[movemotor4]]
  190.         for coords in supercoords:
  191.             stage.move(coords, 0)
  192.             status = stage.xAxisNode.spinStatusRequest()
  193.             while status['stepsRemaining'] > 0:
  194.                 time.sleep(0.001)
  195.                 status = stage.xAxisNode.spinStatusRequest()
  200.     # ser = serial.Serial()
  201.     # ser.braudrate = 115200
  202.     # ser.port = "/dev/tty.usbmodem1411"
  203.     # ser.open()
  204.     def movemotor1(self):
  205.         print "movemotor1called"
  206.         global serialcom, tempmotor1
  207.         movemotor1 = self.motor1.value - tempmotor1
  208.         tempmotor1 = self.motor1.value
  209.         print movemotor1
  210.         # print movemotor2
  211.         # print movemotor3
  212.         if serialcom.isOpen():
  213.             print("serialcomial is open!")
  214.             # serialcom.write('a\n')
  215.             if movemotor1 > 0:
  216.                 for i in range(int(movemotor1)):
  217.                     print 'sending a'
  218.                     serialcom.write('a\n')
  219.                     # time.sleep(.5)
  220.                     # print serialcom.read()
  221.                     print serialcom.readline()
  222.             else:
  223.                 for i in range(abs(int(movemotor1))):
  224.                     serialcom.write('d\n')
  225.                     # time.sleep(.5)
  227.                     # print serialcom.read()
  228.                     print serialcom.readline()
  230.         # serialcom.close()
  233.     def movemotor2(self):
  234.         print "movemotor2called"
  235.         global serialcom, tempmotor2
  236.         movemotor2 = self.motor2.value - tempmotor2
  237.         tempmotor2 = self.motor2.value
  238.         print movemotor2
  239.         if serialcom.isOpen():
  240.             print("serialcomial is open!")
  241.             # serialcom.write('a\n')
  242.             if movemotor2 > 0:
  243.                 for i in range(int(movemotor2)):
  244.                     print 'sending b'
  245.                     serialcom.write('b\n')
  246.                     # time.sleep(.5)
  248.                     # print serialcom.read()
  249.                     print serialcom.readline()
  250.             else:
  251.                 for i in range(abs(int(movemotor2))):
  252.                     serialcom.write('e\n')
  253.                     # time.sleep(.5)
  255.                     # print serialcom.read()
  256.                     print serialcom.readline()
  259.     def movemotor3(self):
  260.         print "movemotor3called"
  261.         global serialcom, tempmotor3
  262.         movemotor3 = self.motor3.value - tempmotor3
  263.         tempmotor3 = self.motor3.value
  264.         print movemotor3
  265.         if serialcom.isOpen():
  266.             print("serialcomial is open!")
  267.             # serialcom.write('a\n')
  268.             if movemotor3 > 0:
  269.                 for i in range(int(movemotor3)):
  270.                     print 'sending c'
  271.                     serialcom.write('c\n')
  272.                     # time.sleep(.5)
  274.                     # print serialcom.read()
  275.                     print serialcom.readline()
  276.             else:
  277.                 for i in range(abs(int(movemotor3))):
  278.                     serialcom.write('f\n')
  279.                     # time.sleep(.5)
  281.                     # print serialcom.read()
  282.                     print serialcom.readline()
  283.     
  284.     
  287. class FabApp(App):
  288.     def build(self):
  289.         global stage
  290.         stage = virtualMachine()
  291.         # print dir(stage.xNode)
  292.         #stage.xNode.loadProgram('../../../086-005/086-005a.hex')
  293.         #stage.xNode.setMotorCurrent(1)
  295.         stage.xNode.setVelocityRequest(8)   
  296.         
  297.         return FabControl()
  300. if __name__ == '__main__':
  301.     FabApp().run()

To run this code on the ubuntu you have to download the kivy module you can download the kivy module by doing two steps below

  • $ sudo add-apt-repository ppa:kivy-team/kivy
    •
  • $ sudo apt-get install python3-kivy
    •

    Once you are done with it you can simplely run the program using the command kivy fabarmkivy.py

    UI Design

    © 2017, made with by scitechindian

    Creative Commons License

    This work done by SYED JUNAID AHMED is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License.