Python Parser.read方法代码示例

# 需要导入模块: from Parser import Parser [as 别名]
# 或者: from Parser.Parser import read [as 别名]
 def _decode(self, shelf):
     root = Registry("root")
     td, fn = split(shelf.name)
     if not td: td = "."
     basename = splitext(fn)[0]
     macros = { 'td': td, 'basename': basename }
     parser = Parser(root, macros=macros)
     parser.read(shelf.name)
     shelf['inventory'] = root
     shelf._frozen = True
     return

# 需要导入模块: from Parser import Parser [as 别名]
# 或者: from Parser.Parser import read [as 别名]
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)

# 需要导入模块: from Parser import Parser [as 别名]
# 或者: from Parser.Parser import read [as 别名]
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()

# 需要导入模块: from Parser import Parser [as 别名]
# 或者: from Parser.Parser import read [as 别名]
def main(): 
    if len(sys.argv) == 1:
        sys.argv.append("examples/tiroler_adler.ngc")
    # STEP 1 - GPIO Initialization
    # bring GPIO to a clean state
    try:
        GPIO.cleanup_existing()
        GPIO.setmode(GPIO.BOARD)
    except AttributeError:
        pass
    # define GPIO Pins to use
    enable_pin = gpio(23, GPIO)
    enable_pin.setup(GPIO.OUT)
    laser_pin = gpio(14, GPIO)
    laser_pin.setup(GPIO.OUT)
    m_x_step = gpio(4, GPIO)
    m_x_step.setup(GPIO.OUT)
    m_x_dir = gpio(2, GPIO)
    m_x_dir.setup(GPIO.OUT)
    m_x_enable = gpio(27, GPIO)
    m_x_enable.setup(GPIO.OUT)
    m_y_step = gpio(22, GPIO)
    m_y_step.setup(GPIO.OUT)
    m_y_dir = gpio(24, GPIO)
    m_y_dir.setup(GPIO.OUT)
    m_y_enable = gpio(25, GPIO)
    m_y_enable.setup(GPIO.OUT)
    m_b_b1 = gpio(7, GPIO)
    m_b_b1.setup(GPIO.OUT)
    m_b_b2 = gpio(8, GPIO)
    m_b_b2.setup(GPIO.OUT)
    logging.info("Initialize GPIO")
    # enable pin for L293D Chip
    enable_pin.output(1)
    # laser power off
    laser_pin.output(0)
    # STEP 2 - create Objects and connect them
    # build our controller
    logging.info("Creating Controller Object")
    controller = Controller(resolution=512/36, default_speed=1.0, autorun=False)
    # step_pin, dir_pin, enable_pin, int max_position, int min_position, double delay, int sos_exception=False
    controller.add_motor("X", StepDirMotor(m_x_step, m_x_dir, m_x_enable, max_position=512, min_position=0, delay=0.002))
    controller.add_motor("Y", StepDirMotor(m_y_step, m_y_dir, m_y_enable, max_position=512, min_position=0, delay=0.002))
    controller.add_motor("Z", LaserMotor(laser_pin=laser_pin, min_position=-10000, max_position=10000, delay=0.00))
    controller.add_spindle(BaseSpindle())
    controller.add_transformer(Transformer())
    # create parser
    logging.info("Creating Parser Object")
    parser = Parser(filename=sys.argv[1], autorun=False)
    parser.set_controller(controller)
    # create gui
    logging.info("Creating GUI")
    # gui = LaserSimulator(automatic=True, zoom=10.0, controller=controller, parser=parser)
    gui = GuiConsole()
    controller.set_gui_cb(gui.controller_cb)
    parser.set_gui_cb(gui.parser_cb)
    # start
    logging.info("Please move stepper motors to origin (0, 0, 0)")
    #key = raw_input("Press any KEY when done")
    # STEP 3 - run 
    # this is usually done from
    try:
        parser.read()
        #key = raw_input("Parsing done, press Return to call controller")
        parser.run()
        #key = raw_input("Controller calculations done, press Return to move")
        controller.run()
        key = raw_input("Controller calculations done, press Return to move")
    except ControllerExit as exc:
        logging.info(exc)
    except Exception as exc:
        logging.exception(exc)
    except KeyboardInterrupt as exc:
        logging.exception(exc)
    # STEP 4 - shutdown
    # inidcate gui to quit
    gui.stop_flag = True
    # cleanup gpio
    GPIO.cleanup()