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)
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()
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()
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]
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)
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)
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()
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)
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()
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)
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()
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()
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()
def update(self): """ Commits the changes """ ShiftRegister.commit() # Commit the serial to parallel
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)