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():
# 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 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():
# 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
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)
