Exemplo n.º 1
0
  def __init__(self, step_pin, dir_pin, fault_key, dac_channel, shiftreg_nr, name):
    """ Init """
    self.dac_channel = dac_channel    # Which channel on the dac is connected to this stepper
    self.step_pin = step_pin
    self.dir_pin = dir_pin
    self.fault_key = fault_key
    self.name = name
    self.enabled = False
    self.in_use = False
    self.steps_pr_mm = 1
    self.microsteps = 1.0
    self.microstepping = 0
    self.direction = 1
    self.current_disabled = False

    # Set up the Shift register
    ShiftRegister.make(8)
    self.shift_reg = ShiftRegister.registers[shiftreg_nr]

    # Set up the GPIO pins - we just have to initialize them so the PRU can flip them
    # terrible hack to cover a bug in Adafruit
    dir_name = "EHRPWM2A" if dir_pin == "GPIO0_22" else dir_pin

    try:
      GPIO.setup(dir_name, GPIO.OUT)
      GPIO.setup(step_pin, GPIO.OUT)
    except ValueError:
      logging.warning("*** Stepper {} Pin {} initialization failure:".format(self.name, dir_name))

    # Add a key code to the key listener
    # Steppers have an nFAULT pin, so callback on falling
    Key_pin(name, fault_key, Key_pin.FALLING, self.fault_callback)
Exemplo n.º 2
0
    def __init__(self, channel, shiftreg_nr, pulse_width_start, pulse_width_stop, init_angle, turnoff_timeout=0):
        """Define a new software controllable servo with adjustable speed control

        Keyword arguments:
        pulse_width_start -- The minimum pulse width defining the lowest angle
        pulse_width_stop -- The maximum pulse width defining the biggest angle
        init_angle -- Initial angle that the servo should take when it is powered on. Range is 0 to 180deg
        turnoff_timeout -- number of seconds after which the servo is turned off if no command is received. 0 = never turns off
        """

        self.pulse_width_start = pulse_width_start
        self.pulse_width_stop = pulse_width_stop
        self.turnoff_timeout = turnoff_timeout

        self.current_pulse_width = (init_angle*(self.pulse_width_stop-self.pulse_width_start)/180.0+self.pulse_width_start)
        self.last_pulse_width = self.current_pulse_width

        self.queue = JoinableQueue(1000)
        self.lastCommandTime = 0

        self.t = Thread(target=self._wait_for_event)
        self.t.daemon = True
        self.running = True
        self.t.start()

        self.pwm = PWM_pin(channel, 100, 0.1)

        # Set up the Shift register for enabling this servo
        ShiftRegister.make()
        self.shift_reg = ShiftRegister.registers[shiftreg_nr]
        self.set_enabled()
Exemplo n.º 3
0
    def __init__(self,
                 channel,
                 pulse_width_start,
                 pulse_width_stop,
                 init_angle,
                 turnoff_timeout=0):
        """Define a new software controllable servo with adjustable speed control

        Keyword arguments:
        pulse_width_start -- The minimum pulse width defining the lowest angle
        pulse_width_stop -- The maximum pulse width defining the biggest angle
        init_angle -- Initial angle that the servo should take when it is powered on. Range is 0 to 180deg
        turnoff_timeout -- number of seconds after which the servo is turned off if no command is received. 0 = never turns off
        """

        self.pulse_width_start = pulse_width_start
        self.pulse_width_stop = pulse_width_stop
        self.turnoff_timeout = turnoff_timeout

        self.current_pulse_width = init_angle * (
            self.pulse_width_stop -
            self.pulse_width_start) / 180.0 + self.pulse_width_start
        self.last_pulse_width = self.current_pulse_width

        self.queue = JoinableQueue(1000)
        self.lastCommandTime = 0

        self.t = Thread(target=self._wait_for_event)
        self.t.daemon = True
        self.running = True
        self.t.start()

        self.pwm = PWM_pin(channel, 100, self.current_pulse_width)

        # Set up the Shift register for enabling this servo
        if channel == "P9_14":
            shiftreg_nr = 3
        elif channel == "P9_16":
            shiftreg_nr = 2
        else:
            logging.warning(
                "Tried to assign servo to an unknown channel/pin: " +
                str(channel))
            return

        ShiftRegister.make()
        self.shift_reg = ShiftRegister.registers[shiftreg_nr]
        self.set_enabled()
Exemplo n.º 4
0
    def __init__(self, stepPin, dirPin, faultPin, dac_channel, shiftreg_nr, name, internalStepPin, internalDirPin):
        """ Init """
        self.dac_channel     = dac_channel  # Which channel on the dac is connected to this stepper
        self.stepPin         = stepPin
        self.dirPin          = dirPin
        self.faultPin        = faultPin
        self.name            = name
        self.enabled 	     = False	    
        self.in_use          = False        
        self.steps_pr_mm     = 1            
        self.microsteps      = 1.0          
        self.direction       = 1
        self.internalStepPin = (1 << internalStepPin)
        self.internalDirPin  = (1 << internalDirPin)

        # Set up the Shift register
        ShiftRegister.make()
        self.shift_reg = ShiftRegister.registers[shiftreg_nr]
Exemplo n.º 5
0
    def __init__(self, stepPin, dirPin, faultPin, dac_channel, shiftreg_nr,
                 name, internalStepPin, internalDirPin):
        """ Init """
        self.dac_channel = dac_channel  # Which channel on the dac is connected to this stepper
        self.stepPin = stepPin
        self.dirPin = dirPin
        self.faultPin = faultPin
        self.name = name
        self.enabled = False
        self.in_use = False
        self.steps_pr_mm = 1
        self.microsteps = 1.0
        self.direction = 1
        self.internalStepPin = (1 << internalStepPin)
        self.internalDirPin = (1 << internalDirPin)

        # Set up the Shift register
        ShiftRegister.make()
        self.shift_reg = ShiftRegister.registers[shiftreg_nr]
Exemplo n.º 6
0
    def __init__(self, step_pin, dir_pin, fault_key, dac_channel, shiftreg_nr, name):
        """ Init """
        self.dac_channel     = dac_channel  # Which channel on the dac is connected to this stepper
        self.step_pin        = step_pin
        self.dir_pin         = dir_pin
        self.fault_key       = fault_key
        self.name            = name
        self.enabled 	     = False	    
        self.in_use          = False        
        self.steps_pr_mm     = 1            
        self.microsteps      = 1.0     
        self.microstepping   = 0
        self.direction       = 1

        # Set up the Shift register
        ShiftRegister.make(8)
        self.shift_reg = ShiftRegister.registers[shiftreg_nr]

        # Add a key code to the key listener
        # Steppers have an nFAULT pin, so callback on falling
        Key_pin(name, fault_key, Key_pin.FALLING, self.fault_callback)
Exemplo n.º 7
0
    def __init__(self, step_pin, dir_pin, fault_key, dac_channel, shiftreg_nr,
                 name):
        """ Init """
        self.dac_channel = dac_channel  # Which channel on the dac is connected to this stepper
        self.step_pin = step_pin
        self.dir_pin = dir_pin
        self.fault_key = fault_key
        self.name = name
        self.enabled = False
        self.in_use = False
        self.steps_pr_mm = 1
        self.microsteps = 1.0
        self.microstepping = 0
        self.direction = 1

        # Set up the Shift register
        ShiftRegister.make(8)
        self.shift_reg = ShiftRegister.registers[shiftreg_nr]

        # Add a key code to the key listener
        # Steppers have an nFAULT pin, so callback on falling
        Key_pin(name, fault_key, Key_pin.FALLING, self.fault_callback)
Exemplo n.º 8
0
    def __init__(self,
                 channel,
                 pulse_width_min,
                 pulse_width_max,
                 angle_min,
                 angle_max,
                 init_angle,
                 turnoff_timeout=0):
        """Define a new software controllable servo with adjustable speed control

        Keyword arguments:
        pulse_width_min -- The minimum pulse width defining the lowest angle
        pulse_width_max -- The maximum pulse width defining the biggest angle
        init_angle -- Initial angle that the servo should take when it is powered on. Range is 0 to 180deg
        turnoff_timeout -- number of seconds after which the servo is turned off if no command is received. 0 = never turns off
        """

        self.angle_min = angle_min
        self.angle_max = angle_max
        self.angle_total = angle_max - angle_min
        self.pulse_width_min = pulse_width_min
        self.pulse_width_max = pulse_width_max
        self.pulse_width_total = pulse_width_max - pulse_width_min

        self.turnoff_timeout = turnoff_timeout

        self.current_pulse_width = self.angle_to_pulse_width(init_angle)
        self.last_pulse_width = self.current_pulse_width

        self.last_angle = init_angle

        self.pulse_length = 20.0 * 10.0**-3.0  # 20 ms

        logging.debug("Angle min: {} deg".format(self.angle_min))
        logging.debug("Angle max: {} deg".format(self.angle_max))
        logging.debug("Angle tot: {} deg".format(self.angle_total))
        logging.debug("Pulse min: {} ms".format(self.pulse_width_min * 1000.0))
        logging.debug("Pulse max: {} ms".format(self.pulse_width_max * 1000.0))
        logging.debug("Pulse tot: {} ms".format(self.pulse_width_total *
                                                1000.0))

        self.queue = JoinableQueue(1000)
        self.lastCommandTime = 0

        self.t = Thread(target=self._wait_for_event, name="Servo")
        self.t.daemon = True
        self.running = True
        self.t.start()

        # Branch based on channel type.

        if type(channel) == int:  # Revision A
            self.pwm = PWM(channel, 50, self.current_pulse_width)
        else:  # Revision B
            # Set up the Shift register for enabling this servo
            if channel == "P9_14":
                shiftreg_nr = 1
                self.pwm = PWM_pin(channel, 50, self.current_pulse_width)
            elif channel == "P9_16":
                shiftreg_nr = 2
                self.pwm = PWM_pin(channel, 50, self.current_pulse_width)
            else:
                logging.warning(
                    "Tried to assign servo to an unknown channel/pin: " +
                    str(channel))
                return

            ShiftRegister.make(5)
            self.shift_reg = ShiftRegister.registers[shiftreg_nr]
        self.set_enabled()
        self.pwm.set_value(
            self.angle_to_pulse_width(init_angle) / self.pulse_length)
Exemplo n.º 9
0
def main(): 
    # bring GPIO to a clean state
    try:
        GPIO.cleanup_existing()
        GPIO.setmode(GPIO.BOARD)
    except AttributeError:
        GPIO.setmode(GPIO.BCM)
    # we use GPIO Wrapper, object like interface to real GPIO Module
    ser = gpio(7, GPIO)
    ser.setup(GPIO.OUT)
    rclk = gpio(8, GPIO)
    rclk.setup(GPIO.OUT)
    srclk = gpio(25, GPIO)
    srclk.setup(GPIO.OUT)
    # in this example a shift register will be used
    shift_register = ShiftRegister(ser, rclk, srclk, 16, autocommit=True)
    # and we use a fake GPIO Object to use ShiftRegister instead
    # Motor A left upper corner
    m_a_dir = ShiftGPIOWrapper(shift_register, 0)
    m_a_step = ShiftGPIOWrapper(shift_register, 1)
    m_a_enable = ShiftGPIOWrapper(shift_register, 2)
    # motor B, should be reversed to A
    m_b_dir = ShiftGPIOWrapper(shift_register, 3)
    m_b_step = ShiftGPIOWrapper(shift_register, 4)
    m_b_enable = ShiftGPIOWrapper(shift_register, 5)
    # Motor C Penholder
    m_c_dir = ShiftGPIOWrapper(shift_register, 6)
    m_c_step = ShiftGPIOWrapper(shift_register, 7)
    m_c_enable = ShiftGPIOWrapper(shift_register, 8)
    try:
        logging.info("Initialize GPIO Modes")
        # build our controller
        logging.info("Creating Controller Object")
        motor_x = A5988DriverMotor(
            enable_pin=m_a_enable,
            dir_pin=m_a_dir,
            step_pin=m_a_step, 
            max_position=9999, 
            min_position=-9999, 
            delay=0.05)
        motor_y = A5988DriverMotor(
            enable_pin=m_b_enable,
            dir_pin=m_b_dir,
            step_pin=m_b_step, 
            max_position=9999, 
            min_position=-9999, 
            delay=0.05)
        motor_z = A5988DriverMotor(
            enable_pin=m_c_enable,
            dir_pin=m_c_dir,
            step_pin=m_c_step, 
            max_position=9999, 
            min_position=-9999, 
            delay=0.05)
        # one turn is 8 mm * pi in 48 steps, motor and screw specifications
        controller = Controller(resolution=8 * math.pi / 48, default_speed=1.0, autorun=False)
        controller.add_motor("X", motor_x)
        controller.add_motor("Y", motor_y)
        controller.add_motor("Z", motor_z)
        controller.add_spindle(BaseSpindle()) # generic spindle object
        transformer = PlotterTransformer(width=830, scale=15.0, ca_zero=320, h_zero=140) # transformer for plotter usage
        controller.add_transformer(transformer) # transformer for plotter usage
        # create parser
        logging.info("Creating Parser Object")
        parser = Parser(filename=FILENAME, autorun=False)
        parser.set_controller(controller)
        # create gui
        logging.info("Creating GUI")
        # gui = PlotterSimulator(automatic=True)
        gui = GuiConsole()
        # connect gui with parser and controller
        gui.set_controller(controller)
        gui.set_parser(parser)
        controller.set_gui_cb(gui.controller_cb)
        parser.set_gui_cb(gui.parser_cb)
        transformer.set_gui_cb(gui.transformer_cb)
        # start
        logging.info("Please move pen to left top corner, the origin")
        # key = raw_input("Press any KEY when done")
        logging.error("start parsing")
        parser.read()
        logging.error("parsing done, calling controller methods")
        parser.run()
        logging.error("controller calculations done, calling physical world")
        controller.run()
        gui.quit()
    except KeyboardInterrupt as exc:
        logging.info(exc)
    except StandardError as exc:
        logging.exception(exc)
    shift_register.clear()
    GPIO.cleanup()
Exemplo n.º 10
0
    parser.add_argument("--direction",
                        "-d",
                        type=int,
                        default=1,
                        help="0 = no scroll, 1 = L->R, 2 = R->L",
                        choices=range(0, 3))
    args = parser.parse_args()

    debug = args.debug

    # setup IO
    io.setwarnings(False)
    io.setmode(io.BOARD)
    io.setup(3, io.OUT)

    sr = ShiftRegister(args.dataPin, args.latchPin, args.clockPin)
    if args.edit:
        t = LedMatrix(sr, 8, 8, 100, args.delay, 0, args.orientation)

        if len(args.message) > 0:
            t.set_message(args.message[0])
        t.start()
        printDebug("Started, about to enter edit mode")
        t.edit()
    elif args.message == "~squares":
        t = LedMatrix(sr, 8 * 7, 8, 100, args.delay, args.direction,
                      args.orientation)

        t.set_letter(Square1)
        t.set_letter(Square2)
        t.set_letter(Square3)
Exemplo n.º 11
0
def main(): 
    # if no parameter option is given, default to example gcode
    if len(sys.argv) == 1:
        sys.argv.append("examples/tiroler_adler.ngc")
    # bring GPIO to a clean state
    try:
        GPIO.cleanup_existing()
    except AttributeError:
        pass
    GPIO.setmode(GPIO.BOARD)
    # we use GPIO Wrapper, object like interface to real GPIO Module
    ser = gpio(23, GPIO)
    ser.setup(GPIO.OUT)
    rclk = gpio(24, GPIO)
    rclk.setup(GPIO.OUT)
    srclk = gpio(25, GPIO)
    srclk.setup(GPIO.OUT)
    # in this example a shift register will be used
    shift_register = ShiftRegister(ser, rclk, srclk, 16, autocommit=True)
    # and we use a fake GPIO Object to use ShiftRegister instead
    m_a_a1 = ShiftGPIOWrapper(shift_register, 0)
    m_a_a2 = ShiftGPIOWrapper(shift_register, 1)
    m_a_b1 = ShiftGPIOWrapper(shift_register, 2)
    m_a_b2 = ShiftGPIOWrapper(shift_register, 3)
    # B-Motor
    m_b_a1 = ShiftGPIOWrapper(shift_register, 6)
    m_b_a2 = ShiftGPIOWrapper(shift_register, 7)
    m_b_b1 = ShiftGPIOWrapper(shift_register, 4)
    m_b_b2 = ShiftGPIOWrapper(shift_register, 5)
    # C-Motor Pen Holder
    m_c_a1 = ShiftGPIOWrapper(shift_register, 8)
    m_c_a2 = ShiftGPIOWrapper(shift_register, 9)
    m_c_b1 = ShiftGPIOWrapper(shift_register, 10)
    m_c_b2 = ShiftGPIOWrapper(shift_register, 11)
    try:
        logging.info("Initialize GPIO Modes")
        # build our controller
        logging.info("Creating Controller Object")
        # one turn is 8 mm * pi in 48 steps, motor and screw specifications
        motor_x = UnipolarStepperMotor(coils=(m_a_a1, m_a_a2, m_a_b1, m_a_b2), max_position=9999, min_position=-9999, delay=0.003)
        motor_y = UnipolarStepperMotor(coils=(m_b_a1, m_b_a2, m_b_b1, m_b_b2), max_position=9999, min_position=-9999, delay=0.003)
        motor_z = UnipolarStepperMotor(coils=(m_c_a1, m_c_a2, m_c_b1, m_c_b2), max_position=10, min_position=-10, delay=0.003, sos_exception=False)
        controller = Controller(resolution=1, default_speed=1.0)
        controller.add_motor("X", motor_x)
        controller.add_motor("Y", motor_y)
        controller.add_motor("Z", motor_z)
        controller.add_spindle(Spindle()) # generic spindle object
        # controller.add_transformer(Transformer()) # transformer for plotter usage
        controller.add_transformer(PlotterTransformer(width=1000, ca_zero=420, h_zero=140, scale=1.0)) # transformer for plotter usage
        # create parser
        logging.info("Creating Parser Object")
        #parser = Parser(filename=sys.argv[1])
        #parser.set_controller(controller)
        # create gui
        logging.info("Creating GUI")
        #gui = PlotterSimulator(automatic=True)
        gui = GcodeGuiConsole()
        # connect gui with parser and controller
        gui.set_controller(controller)
        controller.set_gui_cb(gui.controller_cb)
        #gui.set_parser(parser)
        #parser.set_gui_cb(gui.parser_cb)
        # start
        logging.info("Please move pen to left top corner, the origin")
        # key = raw_input("Press any KEY when done")
        # parser.read()
        pygame.init()
        screen = pygame.display.set_mode((600,400))
        pygame.key.set_repeat(50, 1)
        finished = False
        x = 0
        y = 0
        z = 0
        while not finished:
            # clock.tick(60) # not more than 60 frames per seconds
            # pygame.event.wait()
            event = pygame.event.wait()
            if event.type == pygame.QUIT:
                finished = True
            key = pygame.key.get_pressed()
            if event.type == pygame.KEYDOWN:
                if key[pygame.K_a] : x += 1
                elif key[pygame.K_y] : x -= 1
                elif key[pygame.K_s] : y += 1
                elif key[pygame.K_x] : y -= 1
                elif key[pygame.K_d] : z += 1
                elif key[pygame.K_c] : z -= 1
                else: break
                controller.G00({"X":x, "Y":y, "Z":z})
                print controller.position
    except KeyboardInterrupt as exc:
        logging.info(exc)
    except StandardError as exc:
        logging.exception(exc)
    shift_register.clear()
    GPIO.cleanup()
Exemplo n.º 12
0
    def __init__(self, channel, pulse_width_min, pulse_width_max, angle_min, angle_max, init_angle, turnoff_timeout=0):
        """Define a new software controllable servo with adjustable speed control

        Keyword arguments:
        pulse_width_min -- The minimum pulse width defining the lowest angle
        pulse_width_max -- The maximum pulse width defining the biggest angle
        init_angle -- Initial angle that the servo should take when it is powered on. Range is 0 to 180deg
        turnoff_timeout -- number of seconds after which the servo is turned off if no command is received. 0 = never turns off
        """

        self.angle_min = angle_min
        self.angle_max = angle_max
        self.angle_total = angle_max-angle_min
        self.pulse_width_min = pulse_width_min
        self.pulse_width_max = pulse_width_max
        self.pulse_width_total = pulse_width_max-pulse_width_min
        
        self.turnoff_timeout = turnoff_timeout

        self.current_pulse_width = self.angle_to_pulse_width(init_angle)
        self.last_pulse_width = self.current_pulse_width

        self.last_angle = init_angle

        self.pulse_length = 20.0*10.0**-3.0 # 20 ms

        logging.debug("Angle min: {} deg".format(self.angle_min))
        logging.debug("Angle max: {} deg".format(self.angle_max))
        logging.debug("Angle tot: {} deg".format(self.angle_total))
        logging.debug("Pulse min: {} ms".format(self.pulse_width_min*1000.0))
        logging.debug("Pulse max: {} ms".format(self.pulse_width_max*1000.0))
        logging.debug("Pulse tot: {} ms".format(self.pulse_width_total*1000.0))

        self.queue = JoinableQueue(1000)
        self.lastCommandTime = 0

        self.t = Thread(target=self._wait_for_event)
        self.t.daemon = True
        self.running = True
        self.t.start()

        # Branch based on channel type.

        if type(channel) == int: # Revision A
            self.pwm = PWM(channel, 50, self.current_pulse_width)
        else: # Revision B
            # Set up the Shift register for enabling this servo
            if channel == "P9_14":
                shiftreg_nr = 1
                self.pwm = PWM_pin(channel, 50, self.current_pulse_width)
            elif channel == "P9_16":
                shiftreg_nr = 2
                self.pwm = PWM_pin(channel, 50, self.current_pulse_width)
            else:
                logging.warning("Tried to assign servo to an unknown channel/pin: "+str(channel))
                return        

            ShiftRegister.make(5)
            self.shift_reg = ShiftRegister.registers[shiftreg_nr]
        self.set_enabled()
        self.pwm.set_value(self.angle_to_pulse_width(init_angle)/self.pulse_length)
Exemplo n.º 13
0
def main():
    # bring GPIO to a clean state
    try:
        GPIO.cleanup_existing()
        GPIO.setmode(GPIO.BOARD)
    except AttributeError:
        GPIO.setmode(GPIO.BCM)
    # we use GPIO Wrapper, object like interface to real GPIO Module
    ser = gpio(7, GPIO)
    ser.setup(GPIO.OUT)
    rclk = gpio(8, GPIO)
    rclk.setup(GPIO.OUT)
    srclk = gpio(25, GPIO)
    srclk.setup(GPIO.OUT)
    # in this example a shift register will be used
    shift_register = ShiftRegister(ser, rclk, srclk, 16, autocommit=True)
    # and we use a fake GPIO Object to use ShiftRegister instead
    # Motor A left upper corner
    m_a_dir = ShiftGPIOWrapper(shift_register, 0)
    m_a_step = ShiftGPIOWrapper(shift_register, 1)
    m_a_enable = ShiftGPIOWrapper(shift_register, 2)
    # motor B, should be reversed to A
    m_b_dir = ShiftGPIOWrapper(shift_register, 3)
    m_b_step = ShiftGPIOWrapper(shift_register, 4)
    m_b_enable = ShiftGPIOWrapper(shift_register, 5)
    # Motor C Penholder
    m_c_dir = ShiftGPIOWrapper(shift_register, 6)
    m_c_step = ShiftGPIOWrapper(shift_register, 7)
    m_c_enable = ShiftGPIOWrapper(shift_register, 8)
    try:
        logging.info("Initialize GPIO Modes")
        # build our controller
        logging.info("Creating Controller Object")
        motor_x = A5988DriverMotor(enable_pin=m_a_enable,
                                   dir_pin=m_a_dir,
                                   step_pin=m_a_step,
                                   max_position=9999,
                                   min_position=-9999,
                                   delay=0.05)
        motor_y = A5988DriverMotor(enable_pin=m_b_enable,
                                   dir_pin=m_b_dir,
                                   step_pin=m_b_step,
                                   max_position=9999,
                                   min_position=-9999,
                                   delay=0.05)
        motor_z = A5988DriverMotor(enable_pin=m_c_enable,
                                   dir_pin=m_c_dir,
                                   step_pin=m_c_step,
                                   max_position=9999,
                                   min_position=-9999,
                                   delay=0.05)
        # one turn is 8 mm * pi in 48 steps, motor and screw specifications
        controller = Controller(resolution=8 * math.pi / 48,
                                default_speed=1.0,
                                autorun=False)
        controller.add_motor("X", motor_x)
        controller.add_motor("Y", motor_y)
        controller.add_motor("Z", motor_z)
        controller.add_spindle(BaseSpindle())  # generic spindle object
        transformer = PlotterTransformer(
            width=830, scale=15.0, ca_zero=320,
            h_zero=140)  # transformer for plotter usage
        controller.add_transformer(
            transformer)  # transformer for plotter usage
        # create parser
        logging.info("Creating Parser Object")
        parser = Parser(filename=FILENAME, autorun=False)
        parser.set_controller(controller)
        # create gui
        logging.info("Creating GUI")
        # gui = PlotterSimulator(automatic=True)
        gui = GuiConsole()
        # connect gui with parser and controller
        gui.set_controller(controller)
        gui.set_parser(parser)
        controller.set_gui_cb(gui.controller_cb)
        parser.set_gui_cb(gui.parser_cb)
        transformer.set_gui_cb(gui.transformer_cb)
        # start
        logging.info("Please move pen to left top corner, the origin")
        # key = raw_input("Press any KEY when done")
        logging.error("start parsing")
        parser.read()
        logging.error("parsing done, calling controller methods")
        parser.run()
        logging.error("controller calculations done, calling physical world")
        controller.run()
        gui.quit()
    except KeyboardInterrupt as exc:
        logging.info(exc)
    except StandardError as exc:
        logging.exception(exc)
    shift_register.clear()
    GPIO.cleanup()
Exemplo n.º 14
0
def main():
    # if no parameter option is given, default to example gcode
    if len(sys.argv) == 1:
        sys.argv.append("examples/tiroler_adler.ngc")
    # bring GPIO to a clean state
    try:
        GPIO.cleanup_existing()
    except AttributeError:
        pass
    GPIO.setmode(GPIO.BOARD)
    # we use GPIO Wrapper, object like interface to real GPIO Module
    ser = gpio(23, GPIO)
    ser.setup(GPIO.OUT)
    rclk = gpio(24, GPIO)
    rclk.setup(GPIO.OUT)
    srclk = gpio(25, GPIO)
    srclk.setup(GPIO.OUT)
    # in this example a shift register will be used
    shift_register = ShiftRegister(ser, rclk, srclk, 16, autocommit=True)
    # and we use a fake GPIO Object to use ShiftRegister instead
    m_a_a1 = ShiftGPIOWrapper(shift_register, 0)
    m_a_a2 = ShiftGPIOWrapper(shift_register, 1)
    m_a_b1 = ShiftGPIOWrapper(shift_register, 2)
    m_a_b2 = ShiftGPIOWrapper(shift_register, 3)
    # B-Motor
    m_b_a1 = ShiftGPIOWrapper(shift_register, 6)
    m_b_a2 = ShiftGPIOWrapper(shift_register, 7)
    m_b_b1 = ShiftGPIOWrapper(shift_register, 4)
    m_b_b2 = ShiftGPIOWrapper(shift_register, 5)
    # C-Motor Pen Holder
    m_c_a1 = ShiftGPIOWrapper(shift_register, 8)
    m_c_a2 = ShiftGPIOWrapper(shift_register, 9)
    m_c_b1 = ShiftGPIOWrapper(shift_register, 10)
    m_c_b2 = ShiftGPIOWrapper(shift_register, 11)
    try:
        logging.info("Initialize GPIO Modes")
        # build our controller
        logging.info("Creating Controller Object")
        # one turn is 8 mm * pi in 48 steps, motor and screw specifications
        motor_x = UnipolarStepperMotor(coils=(m_a_a1, m_a_a2, m_a_b1, m_a_b2),
                                       max_position=9999,
                                       min_position=-9999,
                                       delay=0.003)
        motor_y = UnipolarStepperMotor(coils=(m_b_a1, m_b_a2, m_b_b1, m_b_b2),
                                       max_position=9999,
                                       min_position=-9999,
                                       delay=0.003)
        motor_z = UnipolarStepperMotor(coils=(m_c_a1, m_c_a2, m_c_b1, m_c_b2),
                                       max_position=10,
                                       min_position=-10,
                                       delay=0.003,
                                       sos_exception=False)
        controller = Controller(resolution=1, default_speed=1.0)
        controller.add_motor("X", motor_x)
        controller.add_motor("Y", motor_y)
        controller.add_motor("Z", motor_z)
        controller.add_spindle(Spindle())  # generic spindle object
        # controller.add_transformer(Transformer()) # transformer for plotter usage
        controller.add_transformer(
            PlotterTransformer(width=1000, ca_zero=420, h_zero=140,
                               scale=1.0))  # transformer for plotter usage
        # create parser
        logging.info("Creating Parser Object")
        #parser = Parser(filename=sys.argv[1])
        #parser.set_controller(controller)
        # create gui
        logging.info("Creating GUI")
        #gui = PlotterSimulator(automatic=True)
        gui = GcodeGuiConsole()
        # connect gui with parser and controller
        gui.set_controller(controller)
        controller.set_gui_cb(gui.controller_cb)
        #gui.set_parser(parser)
        #parser.set_gui_cb(gui.parser_cb)
        # start
        logging.info("Please move pen to left top corner, the origin")
        # key = raw_input("Press any KEY when done")
        # parser.read()
        pygame.init()
        screen = pygame.display.set_mode((600, 400))
        pygame.key.set_repeat(50, 1)
        finished = False
        x = 0
        y = 0
        z = 0
        while not finished:
            # clock.tick(60) # not more than 60 frames per seconds
            # pygame.event.wait()
            event = pygame.event.wait()
            if event.type == pygame.QUIT:
                finished = True
            key = pygame.key.get_pressed()
            if event.type == pygame.KEYDOWN:
                if key[pygame.K_a]: x += 1
                elif key[pygame.K_y]: x -= 1
                elif key[pygame.K_s]: y += 1
                elif key[pygame.K_x]: y -= 1
                elif key[pygame.K_d]: z += 1
                elif key[pygame.K_c]: z -= 1
                else: break
                controller.G00({"X": x, "Y": y, "Z": z})
                print controller.position
    except KeyboardInterrupt as exc:
        logging.info(exc)
    except StandardError as exc:
        logging.exception(exc)
    shift_register.clear()
    GPIO.cleanup()
Exemplo n.º 15
0
def main():
    # cleanup state and set pin naming mode
    try:
        # for GpioObject
        GPIO.cleanup_existing()
        GPIO.setmode(GPIO.BOARD)
    except AttributeError:
        # for RPi.GPIO
        GPIO.cleanup()
        GPIO.setmode(GPIO.BCM)
    print type(GPIO)
    print GPIO.OUT
    # define necessary pins for shift register
    ser = gpio(7, GPIO)  # labeled S
    ser.setup(GPIO.OUT)
    rclk = gpio(8, GPIO)  # labeled R
    rclk.setup(GPIO.OUT)
    srclk = gpio(25, GPIO)  # labeled SR
    srclk.setup(GPIO.OUT)
    # and shift register, 16 bits wide
    shift_register = ShiftRegister(ser, rclk, srclk, 16, autocommit=False)
    # use some virtual bits in shift register
    # act like GPIO Pins with this Wrapper Class
    # driver 1 dir and step
    d_1_dir_pin = ShiftGPIOWrapper(shift_register, 0)
    d_1_step_pin = ShiftGPIOWrapper(shift_register, 1)
    d_1_enable_pin = ShiftGPIOWrapper(shift_register, 2)
    # driver 2 dir and step
    d_2_dir_pin = ShiftGPIOWrapper(shift_register, 3)
    d_2_step_pin = ShiftGPIOWrapper(shift_register, 4)
    d_2_enable_pin = ShiftGPIOWrapper(shift_register, 5)
    # driver 3 dir and step
    d_3_dir_pin = ShiftGPIOWrapper(shift_register, 6)
    d_3_step_pin = ShiftGPIOWrapper(shift_register, 7)
    d_3_enable_pin = ShiftGPIOWrapper(shift_register, 8)

    steps = 0
    # ENABLE PIN is active LOW
    d1.enable_pin.output(0)
    d2.enable_pin.output(0)
    d3.enable_pin.output(0)

    try:
        d_1_dir_pin.output(DIRECTION)
        d_2_dir_pin.output(DIRECTION)
        d_3_dir_pin.output(DIRECTION)
        shift_register.commit()
        start = time.time()
        while (start + DURATION_S) >= time.time():
            d_1_step_pin.output(True)
            d_2_step_pin.output(True)
            d_3_step_pin.output(True)
            shift_register.commit()
            # time.sleep(0.0001)
            d_1_step_pin.output(False)
            d_2_step_pin.output(False)
            d_3_step_pin.output(False)
            shift_register.commit()
            # time.sleep(STEP_INTERVAL)
            steps += 1
    except KeyboardInterrupt:
        pass
    print "%d steps done" % steps
    shift_register.clear()
    GPIO.cleanup()
Exemplo n.º 16
0
 def update(self):
     """ Commits the changes	"""
     ShiftRegister.commit()  # Commit the serial to parallel
Exemplo n.º 17
0
def main():
    # cleanup state and set pin naming mode
    try:
        # for GpioObject
        GPIO.cleanup_existing()
        GPIO.setmode(GPIO.BOARD)
    except AttributeError:
        # for RPi.GPIO
        GPIO.cleanup()
        GPIO.setmode(GPIO.BCM)
    print type(GPIO)
    print GPIO.OUT
    # define necessary pins for shift register
    ser = gpio(7, GPIO) # labeled S
    ser.setup(GPIO.OUT) 
    rclk = gpio(8, GPIO) # labeled R
    rclk.setup(GPIO.OUT)
    srclk = gpio(25, GPIO) # labeled SR
    srclk.setup(GPIO.OUT)
    # and shift register, 16 bits wide
    shift_register = ShiftRegister(ser, rclk, srclk, 16, autocommit=False)
    # use some virtual bits in shift register
    # act like GPIO Pins with this Wrapper Class
    # driver 1 dir and step
    d_1_dir_pin = ShiftGPIOWrapper(shift_register, 0)
    d_1_step_pin = ShiftGPIOWrapper(shift_register, 1)
    d_1_enable_pin = ShiftGPIOWrapper(shift_register, 2)
    # driver 2 dir and step
    d_2_dir_pin = ShiftGPIOWrapper(shift_register, 3)
    d_2_step_pin = ShiftGPIOWrapper(shift_register, 4)
    d_2_enable_pin = ShiftGPIOWrapper(shift_register, 5)
    # driver 3 dir and step
    d_3_dir_pin = ShiftGPIOWrapper(shift_register, 6)
    d_3_step_pin = ShiftGPIOWrapper(shift_register, 7)
    d_3_enable_pin = ShiftGPIOWrapper(shift_register, 8)
    
    steps = 0
    # ENABLE PIN is active LOW
    d1.enable_pin.output(0)
    d2.enable_pin.output(0)
    d3.enable_pin.output(0)

    try:
        d_1_dir_pin.output(DIRECTION)
        d_2_dir_pin.output(DIRECTION)
        d_3_dir_pin.output(DIRECTION)
        shift_register.commit()
        start = time.time()
        while (start + DURATION_S) >= time.time():
            d_1_step_pin.output(True)
            d_2_step_pin.output(True)
            d_3_step_pin.output(True)
            shift_register.commit()
            # time.sleep(0.0001)
            d_1_step_pin.output(False)
            d_2_step_pin.output(False)
            d_3_step_pin.output(False)
            shift_register.commit()
            # time.sleep(STEP_INTERVAL)
            steps += 1
    except KeyboardInterrupt:
        pass
    print "%d steps done" % steps
    shift_register.clear()
    GPIO.cleanup()
Exemplo n.º 18
0
 def update(self):
     """ Commits the changes	"""
     ShiftRegister.commit()  # Commit the serial to parallel
Exemplo n.º 19
0
def main():
    # if no parameter option is given, default to example gcode
    if len(sys.argv) == 1:
        sys.argv.append("examples/tiroler_adler.ngc")
    # bring GPIO to a clean state
    GPIO.cleanup()
    GPIO.setmode(GPIO.BCM)
    # here we use a shift register
    shift_register = ShiftRegister(23, 24, 25, 16, autocommit=True)
    # and we use a fake GPIO Object to use ShiftRegister instead
    m_a_a1 = ShiftGPIOWrapper(0)
    m_a_a2 = ShiftGPIOWrapper(1)
    m_a_b1 = ShiftGPIOWrapper(2)
    m_a_b2 = ShiftGPIOWrapper(3)
    m_b_a1 = ShiftGPIOWrapper(4)
    m_b_a2 = ShiftGPIOWrapper(5)
    m_b_b1 = ShiftGPIOWrapper(6)
    m_b_b2 = ShiftGPIOWrapper(7)
    m_c_a1 = ShiftGPIOWrapper(8)
    m_c_a2 = ShiftGPIOWrapper(9)
    m_c_b1 = ShiftGPIOWrapper(10)
    m_c_b2 = ShiftGPIOWrapper(11)
    try:
        logging.info("Initialize GPIO Modes")
        # build our controller
        logging.info("Creating Controller Object")
        # one turn is 8 mm * pi in 48 steps, motor and screw specifications
        controller = Controller(resolution=8 * math.pi / 48,
                                default_speed=1.0,
                                delay=0.0)
        controller.add_motor(
            "X",
            UnipolarStepperMotor(coils=(2, 3, 4, 27),
                                 max_position=9999,
                                 min_position=-9999,
                                 delay=0.003))
        controller.add_motor(
            "Y",
            UnipolarStepperMotor(coils=(23, 24, 25, 8),
                                 max_position=9999,
                                 min_position=-9999,
                                 delay=0.003))
        # controller.add_motor("Z", UnipolarStepperMotorOnOff(coils=(14, 15, 9, 7), on_position=10, on_direction=0, delay=0.003))
        controller.add_motor(
            "Z",
            UnipolarStepperMotor(coils=(14, 15, 9, 7),
                                 max_position=20,
                                 min_position=0,
                                 delay=0.003))
        #controller.add_motor("Z", Motor(min_position=-10000, max_position=10000, delay=0.0))
        controller.add_spindle(Spindle())  # generic spindle object
        controller.add_transformer(
            PlotterTransformer(width=1000, heigth=500,
                               scale=20.0))  # transformer for plotter usage
        # create parser
        logging.info("Creating Parser Object")
        parser = Parser(filename=sys.argv[1])
        parser.set_controller(controller)
        # create gui
        logging.info("Creating GUI")
        gui = PlotterSimulator(automatic=True)
        # gui = GcodeGuiConsole()
        # connect gui with parser and controller
        gui.set_controller(controller)
        controller.set_gui_cb(gui.controller_cb)
        gui.set_parser(parser)
        parser.set_gui_cb(gui.parser_cb)
        # start
        logging.info("Please move pen to left top corner, the origin")
        #key = raw_input("Press any KEY when done")
        parser.read()
    except ControllerExit, exc:
        logging.info(exc)