def printAllRules(self):
for key in self.bcr:
for element in self.bcr[key]:
print " ", Printer().deref(
element[0],
{}), ":-", str(Printer().deref(element[1], {})) + "."
print ""
def prove(self, goals):
print "?-", Printer().deref(goals, {})
Cut().reset()
gvars = self.get_variables(goals)
result = self.bcprove(goals, {}, gvars, 0)
print Printer().deref(result, {}), "\n"
return result
def mock_lab_print(num_seconds, pages_per_minute):
"""
:param num_seconds int 表示要模拟的时长 以秒为单位 例如 要模拟1小时 则该参数值为3600
:param pages_per_minute int 表示打印机的速度 单位为页数/分钟
"""
# 初始化打印机
printer = Printer(pages_per_minute)
# 初始化任务队列
tasks = Queue()
# 等待时间列表
wait_times = []
for current_timestamp in range(num_seconds):
if is_new_task():
# 创建任务 以当前的计步器值为任务的创建时刻
task = Task(current_timestamp)
tasks.enqueue(task)
if (not printer.is_busy()) and (not tasks.is_empty()):
# 取出下一个任务
next_task = tasks.dequeue()
# 以下一个任务进入打印机的时刻为任务开始被执行的时刻
wait_times.append(next_task.wait_time(current_timestamp))
# 打印机开始下一个任务
printer.start_next(next_task)
# 打印机开始工作
printer.tick()
average_wait_time = sum(wait_times) / len(wait_times)
print("Average Wait %6.2f secs %3d tasks finished." %
(average_wait_time, tasks.size()))
def listAppoitmentByCustomer(self):
customer = self.askCustomerInfo(False)
while (customer == None):
customer = self.askCustomerInfo(False)
clientAppoitments = [n for n in self.repository.appointments if n.customer.cpf == customer.cpf]
order = int(input("Enter the order for the report\n1.Task code\n2.Date\n3.Task name\n"))
if (order == 1):
sortedAppoitments = sorted(clientAppoitments, key=lambda x: x.task.code, reverse=False)
elif (order == 2):
sortedAppoitments = sorted(clientAppoitments, key=lambda x: x.date, reverse=False)
elif (order == 3):
sortedAppoitments = sorted(clientAppoitments, key=lambda x: x.task.name, reverse=False)
printer = Printer()
printer.addPrintingObject("Date", True, 10)
printer.addPrintingObject("Hour", True, 4)
printer.addPrintingObject("Employee's name", True, 25)
printer.addPrintingObject("Customers's name", True, 25)
printer.addPrintingObject("Vehicle's model", True, 25)
printer.addPrintingObject("Status", True, 25)
printer.addPrintingObject("Task", True, 25)
printer.printHeader()
for appointment in sortedAppoitments:
print(printer.formatValue(0, appointment.date) +
printer.formatValue(1, appointment.dateHour) +
printer.formatValue(2, appointment.employee.name) +
printer.formatValue(3, appointment.customer.name) +
printer.formatValue(4, appointment.vehicle.model) +
printer.formatValue(5, appointment.status) +
printer.formatValue(6, appointment.task.name))
def __init__(self):
'''
Constructor
'''
# logging.basicConfig(level=logging.DEBUG, disable_existing_loggers=False)
# self.logger = logging.getLogger(__name__)
self.gameOver = False
self.printer = Printer(self)
self.WI = WorldItems()
self.player = self.__initPlayer()
# Enemies
self.EG = EnemyGenerator(self.WI)
self.currentEnemy = ""
self.story = Story(self)
self.printer.intro(self.player)
self.player.listInventory()
raw_input()
self.nbTurn = 0
print("##################################################")
print(" THE GAME BEGINS")
print("##################################################")
self.nextEvent = self.story.goToEvent("intro")
def print(self, process):
print("printing")
try:
logging.debug("Form_Main: print - printing")
if len(self.goodlist) > 0:
self.ui.pushButton_ok.setDisabled(True)
printer = Printer()
printer.print(self.goodlist[0].title, self.goodlist[0].barcode,
"1", self.goodlist[0].price,
self.goodlist[0].amount,
datetime.datetime.now().strftime('%Y-%m-%d'),
self.goodlist[0].exp, self.goodlist[0].net,
self.goodlist[0].code)
self.UploadOrder(self.goodlist[0])
time.sleep(2)
self.ui.pushButton_ok.setDisabled(False)
else:
self.ui.pushButton_ok.setDisabled(True)
pass
process.goodsconfirm_done = True
print("goodsconfirm_done:" + str(process.goodsconfirm_done))
self.ui.pushButton_ok.disconnect()
except Exception as e:
print(str(e))
logging.debug("Form_Main: print - printed")
def reduce_movie_files(filename, d, max_id=17770):
m = Printer(max_id)
fd = open(d['output_name'] + ".csv", "w")
fd.write("movieid," + d['column_name'] + "\n")
for i in range(1, max_id + 1):
m.update()
movie_id = 0
lines_array = []
with open(filename + str(i) + ".txt") as infile:
for line in infile:
if movie_id == 0:
movie_id = line.split(":", 1)[0]
else:
lines_array.append(line[:-1].split(","))
fun = d['fun']
n = None
if fun is not None:
n = fun(lines_array, d['valor_inicial'])
fd.write(str(movie_id) + "," + str(n) + "\n")
m.close()
fd.close()
def make_customer_file(filename, d, max_id=17770):
print "Leyendo archivos movie"
m = Printer(max_id)
new_filename = d['output_name'] + ".csv"
fd = open(new_filename, "w")
fd.write("customerid," + d['column_name'] + "\n")
customer_array = MyArrayList()
for i in range(1, max_id + 1):
m.update()
with open(filename + str(i) + ".txt") as infile:
for line in infile:
if ':' in line:
continue
else:
customer_array.insert(line[:-1].split(","))
m.close()
print "Creando archivo " + new_filename
m.reset(customer_array.get_length())
compare = d['compare']
customer_array.sort(compare)
for i in range(0, customer_array.get_length()):
m.update()
fd.write(customer_array.toLine(i))
m.close()
fd.close()
return customer_array.get_length() + 1
def __init__(self):
self.portForReceiving = 0
self.portForSending = 0
self.id = 0
self.printer = Printer()
# Green node comunication points.
self.agentForReceiving = None
self.agentForSending = None
self.fromGreenNodeDispatcher = FromGreenNodeDispatcher(self.printer)
# Spanning Tree
self.spanningTreeMiniDispatcher = SpanningTreeMiniDispatcher(
self.printer)
self.sharedNotifier = SharedNotifier()
self.spanningTreeSendingSide = SpanningTreeSendingSide(self.printer)
self.spanningTreeReceivingSide = SpanningTreeReceivingSide(
self.printer)
self.spanningTreeUpdatesNotifier = SpanningTreeUpdatesNotifier()
self.spanningTreeDisconnectionHandler = SpanningTreeDisconnectionHandler(
self.printer)
self.dijkstraModule=Dijkstra()
def simulation(numSeconds, pagePerMinute):
"""Return result of simulation of printer queue bellow numSeconds with
a rate of pagePerMinute (Supposing that a task is complete once every 180
seconds (probability), and the pages range from 1 to 20 pages."""
printerQueue = Queue()
labPrinter = Printer(pagePerMinute)
waitingList = []
for currentSecond in range(numSeconds):
if newPrintTask():
# If a new task is created we enqueue it to the queue with the
# second it was enqueued.
task = Task(currentSecond)
printerQueue.enqueue(task)
if not labPrinter.busy() and not printerQueue.isEmpty():
nextTask = printerQueue.dequeue() # Dequeue the next element.
waitingTime = nextTask.waitTime(currentSecond)
# This calculated how many time passed since the task was created
# until it started to process. First task always 0.
waitingList.append(waitingTime)
labPrinter.startNext(nextTask) # Only executed when the task is
# done and there are more elements in queue.
labPrinter.tick()
avgWait = sum(waitingList) / len(waitingList)
return "Avg time per task {:.2f} sec, {} tasks on queue."\
.format(avgWait, printerQueue.size())
def main(argv):
rd = Reader()
ev = Evaluator()
pr = Printer()
program = rd.read(argv[1])
pr.prnt(program)
value = ev.eval(program)
pr.prnt(value)
def __init__(self, include=None, exclude=None):
super().__init__("Display1", _print=False)
self.printer = Printer()
if include is None:
include = list()
if exclude is None:
exclude = list()
self.include = include
self.exclude = exclude
def stopNotifier(self):
for f in self.watchPaths:
self.wm.rm_watch(list(f.getWatcher().values()))
Printer(self.notifier)
self.watchPaths = []
# following thing does not work. Issue #33: https://github.com/seb-m/pyinotify/issues/33
if self.run:
self.notifier.stop()
self.run = False
def __init__(self, client_id, _class=TicketData, _print=True):
super().__init__(client_id)
self.connect()
self.test_network_connection()
self.data = list()
assert issubclass(_class, TicketData)
self.ticket_type = _class
self.printer = Printer()
self.print = _print
self.start_printer()
def draw(self, ctx):
dpi = 96
nastavitve = ET.ElementTree(file=self._nastavitve).getroot()
odmik_desni = int(nastavitve.find("odmiki/odmik_od_desnega_roba").text)
odmik_levi = int(nastavitve.find("odmiki/odmik_od_levega_roba").text)
visina = int(nastavitve.find("kuverte/visina").text)
sirina = int(nastavitve.find("kuverte/sirina").text)
velikost_mm = (sirina, visina)
pisava_x = nastavitve.find("pisava").text
spl = pisava_x.split(" ")
pisava_size = font_size_to_pixel(int(spl[len(spl) - 1]), dpi)
if pisava_x.rfind(",") != -1:
pisava = pisava_x[0:pisava_x.rfind(",")]
else:
pisava = pisava_x[0:pisava_x.rfind(" ")]
velikost_pix = (mm_to_pixel(velikost_mm[0],
dpi), mm_to_pixel(velikost_mm[1], dpi))
odmik_desno = mm_to_pixel(odmik_desni, dpi)
odmik_spodaj = mm_to_pixel(odmik_levi, dpi)
razmik_vrstice = mm_to_pixel(2, dpi)
bes = self.u_data["m_naziv"] + " " + self.u_data[
"m_ime"] + "\n" + self.u_data[
"m_naslov"] + "\n" + "\n" + self.u_data["m_posta"]
if self.u_data["m_drzava"] != "":
bes + "\n" + self.u_data["m_drzava"]
p = Printer()
ctx.translate(self.rp_sirina / 2, self.rp_visina / 2)
ctx.rotate(self.rotacija * (3.14 / 180))
ctx.translate(-(self.rp_sirina / 2), -(self.rp_visina / 2))
ctx.translate(
(self.rp_sirina - (velikost_pix[0] * self.zoom_faktor)) / 2,
(self.rp_visina - (velikost_pix[1] * self.zoom_faktor)) / 2)
ctx.scale(self.zoom_faktor, self.zoom_faktor)
ims = p.narediPNGKuverto(besedilo=bes,
pisava=pisava,
velikost_pisave=pisava_size,
visina=velikost_pix[1],
sirina=velikost_pix[0],
odmik_desno=odmik_desno,
odmik_spodaj=odmik_spodaj,
razmik_vrstice=razmik_vrstice,
show_crte=self.kuv_show_crte,
ctx_p=ctx)
def __init__(self):
super().__init__()
self.ticket_printer = Printer()
self.ticket_generator = None
self.network = False
self.connected = False
self.test_network_connection()
self.connect()
self.print_tickets()
self.get_time() # deprecate
self.show_num_tickets = NUM_TICKETS
def __init__(self):
super().__init__()
self.network = False
self.connected = False
self.test_network_connection()
self.connect_task = self.connect()
self.receipt_printer = Printer()
self.cash_drawer = Drawer()
self.screen = LCDScreen()
self.stdout = logging.getLogger(f"main.{self.client_id}.gui.stdout")
self.stderr = logging.getLogger(f"main.{self.client_id}.gui.stderr")
self.last_total = 0
self.last_no = 0
self.last_tab = ""
self.pause_screen_update = False
def bcprove(self, goals, env, gvars, level):
elements = []
for goal in goals:
if isinstance(goal, bool):
elements.append(goal)
elif type(goal[0]) == type((1, )):
for tup in goal:
elements.append(tup)
else:
elements.append(goal)
if len(elements) == 1 and isinstance(elements[0], bool):
if not elements[0]:
return False
print elements[0]
for x in gvars:
print x.name + ": " + str(Printer().deref(x, env))
return Printer().query_yes_no("more solutions?", "no") == "no"
return self.solve(elements, env, gvars, level)
def fix_movie_titles(filename, d):
print "Leyendo archivo " + filename
n = numero_lineas(filename)
new_filename = d['output_name'] + ".csv"
fd = open(new_filename, "w")
fd.write(d['column_name'] + "\n")
print "Creando archivo " + new_filename
m = Printer(n)
with open(filename) as infile:
for line in infile:
m.update()
fd.write(line)
m.close()
fd.close()
return n + 1
def simulation(num_seconds, pages_per_minute):
lab_printer = Printer(pages_per_minute)
print_queue = Queue()
waiting_times = []
for current_second in range(num_seconds):
if new_print_task():
task = Task(current_second)
print_queue.enqueue(task)
if (not lab_printer.busy()) and (not print_queue.is_empty()):
next_task = print_queue.dequeue()
waiting_times.append(next_task.wait_time(current_second))
lab_printer.start_next(next_task)
lab_printer.tick()
average_wait = sum(waiting_times) / len(waiting_times)
print("Average Wait %6.2f secs %3d tasks remaining." %
(average_wait, print_queue.size()))
def __init__(self, width, height):
# Base constructor
QtOpenGL.QGLWidget.__init__(self)
self.setMouseTracking(True)
self.width = width
self.height = height
# Initialize the painter
self.painter = QtGui.QPainter()
self.printer = Printer()
self.gender = -1
self.avatarImg = None
self.avatarTex = None
# Adding the avatar buttons
# Avatar Male
self.initMImg = pygame.image.load("../../images/wireframe_m0.png")
self.initMTex = 0
# Avatar Female
self.initFImg = pygame.image.load("../../images/wireframe_f0.png")
self.initFTex = 0
self.welcomeImg = pygame.image.load(
"../../images/welcome_intro/welcome_noavatars.png")
self.welcomeTex = 0
# self.btnGraph1 = Button(u"\u25c4", 10, 15, 100, 50)
# self.btnGraph2 = Button(u"\u25ba", self.width - 110, 15, 100, 50)
self.Next1btn = Button(u"\u25ba", self.width - 110, 15, 100, 50)
self.Next1btn.disable()
self.Next2btn = Button(u"\u25ba", self.width - 110, 15, 100, 50)
self.Next2btn.disable()
self.Next3btn = Button(u"\u25ba", self.width - 110, 15, 100, 50)
self.Next3btn.disable()
self.btnOkay = Button("DONE", self.width - 130, 15, 120, 50)
self.btnOkay.disable()
self.Back1btn = Button(u"\u25c4", 10, 15, 100, 50)
self.Back1btn.disable()
self.Back2btn = Button(u"\u25c4", 10, 15, 100, 50)
self.Back2btn.disable()
self.Back3btn = Button(u"\u25c4", 10, 15, 100, 50)
self.Back3btn.disable()
self.showing = self.SELECT_SCREEN
def create_super_file(filename, d, max_id=17770):
m = Printer(max_id)
fd = open(d['output_name'] + ".csv", "w")
fd.write("movieid," + d['column_name'] + "\n")
for i in range(1, max_id + 1):
m.update()
movie_id = 0
lines_array = []
with open(filename + str(i) + ".txt") as infile:
for line in infile:
if movie_id == 0:
movie_id = line.split(":", 1)[0]
else:
fd.write(str(movie_id) + "," + line)
m.close()
fd.close()
def simulation(numSeconds, pagePerMin):
labPrinter = Printer(pagePerMin)
printQ = Queue()
waitTime = []
for currentSecond in range(numSeconds):
if newPrintTask():
task = Task(currentSecond)
printQ.enqueue(task)
if (not labPrinter.busy()) and (not printQ.is_empty()):
nextTask = printQ.dequeue()
waitTime.append(nextTask.waitTime(currentSecond))
labPrinter.startNext(nextTask)
labPrinter.tick()
avgWait = sum(waitTime) / len(waitTime)
print("Avg wait: %6.2f secs, Tasks remaining: %3d" %
(avgWait, printQ.size()))
def askTaskInfo(self):
availableTasks = AvailableTask()
availableTasks.getAllAvailableTasks()
print("Select task to be executed: ")
printer = Printer()
printer.addPrintingObject("ID", True, 3)
printer.addPrintingObject("Name", True, 30)
printer.addPrintingObject("Description", True, 30)
printer.printHeader()
tasks = availableTasks.getAllAvailableTasks()
for key in tasks:
task = tasks[key]
print(printer.formatValue(0, key) +
printer.formatValue(1, task.name) +
printer.formatValue(2, task.description))
return availableTasks.getAvailableTask(int(input("Please enter task's ID: ")))
def ask(self, query, mores=True):
"""Ask returns a substitution that makes the query true, or
it returns False. It is implemented in trems of ask_generator."""
key = self.make_key(query)
gvars = self.get_variables(query)
iterator = self.wm[key].__iter__()
try:
unifier = Unify()
printer = Printer()
r = unifier.unify(iterator.next(), query, {})
while True:
if r:
for x in gvars:
print x.name + ": " + str(printer.deref(x, r))
# print r
if printer.query_yes_no("more solutions?", "no") == "no":
return True
r = unifier.unify(iterator.next(), query, {})
except StopIteration:
return False
def simulation(numSeconds,pagesPerMinute):
labPrinter = Printer(pagesPerMinute) #初始化打印机
printQueue = Queue() #初始化任务等待队
waitingTimes = [] #记录每个任务的等待时间
for currentSecond in range(numSeconds): #0~3600s
if newPrintTask(): #创建新任务
task = Task(currentSecond)#当前任务及时间
printQueue.enqueue(task)#进入打印队列
#print('newPrintTask')
if (not labPrinter.isBusy() ) and (not printQueue.isEmpty()):#打印机空闲并且有任务在等待
nextTask = printQueue.dequeue() #弹出下一个任务
waitingTimes.append(nextTask.waitTime(currentSecond)) #计算并记录等待时间
labPrinter.loadNext(nextTask) #载入新的任务
labPrinter.printTick()
averageWait = sum(waitingTimes)/len(waitingTimes)
print("Average Wait %6.2f secs %3d tasks remaining."%(averageWait,printQueue.size()))
def simulation(numSeconds, pagesPerMinute):
labprinter = Printer(pagesPerMinute)
printQueue = Queue()
waitingtimes = []
for currentSecond in range(numSeconds):
if newPrintTask():
task = Task(currentSecond)
printQueue.enqueue(task)
if (not labprinter.busy()) and (not printQueue.isEmpty()):
nexttask = printQueue.dequeue()
waitingtimes.append(nexttask.waitTime(currentSecond))
labprinter.startNext(nexttask)
labprinter.tick()
averageWait = sum(waitingtimes) / len(waitingtimes)
print("Average Wait %6.2f secs %3d tasks remaining." %(averageWait, printQueue.size()))
def monitor(config):
monitor_intervals = config["global"]["monitor_intervals"]
last_result = {}
kafka_time_line = {}
es_time_line = {}
start_time = time.strftime("%m-%d %X", time.localtime())
while True:
print 120 * "*"
print 55 * " " + "Started Monitor at %s" % start_time
print 120 * "*" + 3 * "\n"
scheduler = Scheduler(config)
result = scheduler.scheduler()
printer = Printer(config)
printer.flume_printer(result)
kafka_time_line = printer.kafka_printer(last_result, result,
kafka_time_line)
es_time_line = printer.es_printer(last_result, result, es_time_line)
last_result = result
print 4 * "\n"
sleep(monitor_intervals)
def __init__(self, game):
super(GameFrame, self).__init__(None, title='Zoo', size=(765, 800))
self.printer = Printer(self)
self.game = game
self.notifications = []
self.game.printer = self.printer
self.game.set_notifications(self.notifications)
self.notificationsWindow = wx.TextCtrl(self, -1, style=wx.TE_MULTILINE | wx.TE_READONLY | wx.TE_WORDWRAP)
self.inputHandler = InputHandler(self)
# arrange stuff
box = wx.BoxSizer(orient=wx.VERTICAL)
box.Add(self.printer, 15, flag=wx.ALL, border=5)
box.Add(self.notificationsWindow, 3, flag=wx.ALL | wx.EXPAND, border=5)
box.Add(self.inputHandler, -1, flag=wx.ALL | wx.EXPAND, border=5)
self.update_loop()
self.SetSizer(box)
self.Center()
self.Show()
def __init__(self):
firmware_version = "1.1.8~Raw Deal"
logging.info("Redeem initializing " + firmware_version)
printer = Printer()
self.printer = printer
Path.printer = printer
printer.firmware_version = firmware_version
# check for config files
if not os.path.exists("/etc/redeem/default.cfg"):
logging.error(
"/etc/redeem/default.cfg does not exist, this file is required for operation"
)
sys.exit() # maybe use something more graceful?
if not os.path.exists("/etc/redeem/local.cfg"):
logging.info("/etc/redeem/local.cfg does not exist, Creating one")
os.mknod("/etc/redeem/local.cfg")
# Parse the config files.
printer.config = CascadingConfigParser([
'/etc/redeem/default.cfg', '/etc/redeem/printer.cfg',
'/etc/redeem/local.cfg'
])
# Get the revision and loglevel from the Config file
level = self.printer.config.getint('System', 'loglevel')
if level > 0:
logging.getLogger().setLevel(level)
# Set up additional logging, if present:
if self.printer.config.getboolean('System', 'log_to_file'):
logfile = self.printer.config.get('System', 'logfile')
formatter = '%(asctime)s %(name)-12s %(levelname)-8s %(message)s'
printer.redeem_logging_handler = logging.handlers.RotatingFileHandler(
logfile, maxBytes=2 * 1024 * 1024)
printer.redeem_logging_handler.setFormatter(
logging.Formatter(formatter))
printer.redeem_logging_handler.setLevel(level)
logging.getLogger().addHandler(printer.redeem_logging_handler)
logging.info("-- Logfile configured --")
# Find out which capes are connected
self.printer.config.parse_capes()
self.revision = self.printer.config.replicape_revision
if self.revision:
logging.info("Found Replicape rev. " + self.revision)
else:
logging.warning("Oh no! No Replicape present!")
self.revision = "00B3"
# We set it to 5 axis by default
Path.NUM_AXES = 5
if self.printer.config.reach_revision:
logging.info("Found Reach rev. " +
self.printer.config.reach_revision)
if self.printer.config.reach_revision == "00A0":
Path.NUM_AXES = 8
elif self.printer.config.reach_revision == "00B0":
Path.NUM_AXES = 7
if self.revision in ["00A4", "0A4A", "00A3"]:
PWM.set_frequency(100)
elif self.revision in ["00B1", "00B2", "00B3"]:
PWM.set_frequency(1000)
# Test the alarm framework
Alarm.printer = self.printer
Alarm.executor = AlarmExecutor()
alarm = Alarm(Alarm.ALARM_TEST, "Alarm framework operational")
# Init the Watchdog timer
printer.watchdog = Watchdog()
# Enable PWM and steppers
printer.enable = Enable("P9_41")
printer.enable.set_disabled()
# Init the Paths
Path.axis_config = printer.config.getint('Geometry', 'axis_config')
# Init the end stops
EndStop.inputdev = self.printer.config.get("Endstops", "inputdev")
# Set up key listener
Key_pin.listener = Key_pin_listener(EndStop.inputdev)
for es in ["Z2", "Y2", "X2", "Z1", "Y1",
"X1"]: # Order matches end stop inversion mask in Firmware
pin = self.printer.config.get("Endstops", "pin_" + es)
keycode = self.printer.config.getint("Endstops", "keycode_" + es)
invert = self.printer.config.getboolean("Endstops", "invert_" + es)
self.printer.end_stops[es] = EndStop(printer, pin, keycode, es,
invert)
self.printer.end_stops[es].stops = self.printer.config.get(
'Endstops', 'end_stop_' + es + '_stops')
# Init the 5 Stepper motors (step, dir, fault, DAC channel, name)
if self.revision == "00A3":
printer.steppers["X"] = Stepper_00A3("GPIO0_27", "GPIO1_29",
"GPIO2_4", 0, "X")
printer.steppers["Y"] = Stepper_00A3("GPIO1_12", "GPIO0_22",
"GPIO2_5", 1, "Y")
printer.steppers["Z"] = Stepper_00A3("GPIO0_23", "GPIO0_26",
"GPIO0_15", 2, "Z")
printer.steppers["E"] = Stepper_00A3("GPIO1_28", "GPIO1_15",
"GPIO2_1", 3, "E")
printer.steppers["H"] = Stepper_00A3("GPIO1_13", "GPIO1_14",
"GPIO2_3", 4, "H")
elif self.revision == "00B1":
printer.steppers["X"] = Stepper_00B1("GPIO0_27", "GPIO1_29",
"GPIO2_4", 11, 0, "X")
printer.steppers["Y"] = Stepper_00B1("GPIO1_12", "GPIO0_22",
"GPIO2_5", 12, 1, "Y")
printer.steppers["Z"] = Stepper_00B1("GPIO0_23", "GPIO0_26",
"GPIO0_15", 13, 2, "Z")
printer.steppers["E"] = Stepper_00B1("GPIO1_28", "GPIO1_15",
"GPIO2_1", 14, 3, "E")
printer.steppers["H"] = Stepper_00B1("GPIO1_13", "GPIO1_14",
"GPIO2_3", 15, 4, "H")
elif self.revision == "00B2":
printer.steppers["X"] = Stepper_00B2("GPIO0_27", "GPIO1_29",
"GPIO2_4", 11, 0, "X")
printer.steppers["Y"] = Stepper_00B2("GPIO1_12", "GPIO0_22",
"GPIO2_5", 12, 1, "Y")
printer.steppers["Z"] = Stepper_00B2("GPIO0_23", "GPIO0_26",
"GPIO0_15", 13, 2, "Z")
printer.steppers["E"] = Stepper_00B2("GPIO1_28", "GPIO1_15",
"GPIO2_1", 14, 3, "E")
printer.steppers["H"] = Stepper_00B2("GPIO1_13", "GPIO1_14",
"GPIO2_3", 15, 4, "H")
elif self.revision == "00B3":
printer.steppers["X"] = Stepper_00B3("GPIO0_27", "GPIO1_29", 90,
11, 0, "X")
printer.steppers["Y"] = Stepper_00B3("GPIO1_12", "GPIO0_22", 91,
12, 1, "Y")
printer.steppers["Z"] = Stepper_00B3("GPIO0_23", "GPIO0_26", 92,
13, 2, "Z")
printer.steppers["E"] = Stepper_00B3("GPIO1_28", "GPIO1_15", 93,
14, 3, "E")
printer.steppers["H"] = Stepper_00B3("GPIO1_13", "GPIO1_14", 94,
15, 4, "H")
elif self.revision in ["00A4", "0A4A"]:
printer.steppers["X"] = Stepper_00A4("GPIO0_27", "GPIO1_29",
"GPIO2_4", 0, 0, "X")
printer.steppers["Y"] = Stepper_00A4("GPIO1_12", "GPIO0_22",
"GPIO2_5", 1, 1, "Y")
printer.steppers["Z"] = Stepper_00A4("GPIO0_23", "GPIO0_26",
"GPIO0_15", 2, 2, "Z")
printer.steppers["E"] = Stepper_00A4("GPIO1_28", "GPIO1_15",
"GPIO2_1", 3, 3, "E")
printer.steppers["H"] = Stepper_00A4("GPIO1_13", "GPIO1_14",
"GPIO2_3", 4, 4, "H")
# Init Reach steppers, if present.
if printer.config.reach_revision == "00A0":
printer.steppers["A"] = Stepper_reach_00A4("GPIO2_2", "GPIO1_18",
"GPIO0_14", 5, 5, "A")
printer.steppers["B"] = Stepper_reach_00A4("GPIO1_16", "GPIO0_5",
"GPIO0_14", 6, 6, "B")
printer.steppers["C"] = Stepper_reach_00A4("GPIO0_3", "GPIO3_19",
"GPIO0_14", 7, 7, "C")
elif printer.config.reach_revision == "00B0":
printer.steppers["A"] = Stepper_reach_00B0("GPIO1_16", "GPIO0_5",
"GPIO0_3", 5, 5, "A")
printer.steppers["B"] = Stepper_reach_00B0("GPIO2_2", "GPIO0_14",
"GPIO0_3", 6, 6, "B")
# Enable the steppers and set the current, steps pr mm and
# microstepping
for name, stepper in self.printer.steppers.iteritems():
stepper.in_use = printer.config.getboolean('Steppers',
'in_use_' + name)
stepper.direction = printer.config.getint('Steppers',
'direction_' + name)
stepper.has_endstop = printer.config.getboolean(
'Endstops', 'has_' + name)
stepper.set_current_value(
printer.config.getfloat('Steppers', 'current_' + name))
stepper.set_steps_pr_mm(
printer.config.getfloat('Steppers', 'steps_pr_mm_' + name))
stepper.set_microstepping(
printer.config.getint('Steppers', 'microstepping_' + name))
stepper.set_decay(
printer.config.getint("Steppers", "slow_decay_" + name))
# Add soft end stops
Path.soft_min[Path.axis_to_index(name)] = printer.config.getfloat(
'Endstops', 'soft_end_stop_min_' + name)
Path.soft_max[Path.axis_to_index(name)] = printer.config.getfloat(
'Endstops', 'soft_end_stop_max_' + name)
slave = printer.config.get('Steppers', 'slave_' + name)
if slave:
Path.add_slave(name, slave)
logging.debug("Axis " + name + " has slave " + slave)
# Commit changes for the Steppers
#Stepper.commit()
Stepper.printer = printer
# Delta printer setup
if Path.axis_config == Path.AXIS_CONFIG_DELTA:
opts = [
"Hez", "L", "r", "Ae", "Be", "Ce", "A_radial", "B_radial",
"C_radial", "A_tangential", "B_tangential", "C_tangential"
]
for opt in opts:
Delta.__dict__[opt] = printer.config.getfloat('Delta', opt)
Delta.recalculate()
# Discover and add all DS18B20 cold ends.
import glob
paths = glob.glob("/sys/bus/w1/devices/28-*/w1_slave")
logging.debug("Found cold ends: " + str(paths))
for i, path in enumerate(paths):
self.printer.cold_ends.append(ColdEnd(path, "ds18b20-" + str(i)))
logging.info("Found Cold end " + str(i) + " on " + path)
# Make Mosfets, thermistors and extruders
heaters = ["E", "H", "HBP"]
if self.printer.config.reach_revision:
heaters.extend(["A", "B", "C"])
for e in heaters:
# Mosfets
channel = self.printer.config.getint("Heaters", "mosfet_" + e)
self.printer.mosfets[e] = Mosfet(channel)
# Thermistors
adc = self.printer.config.get("Heaters", "path_adc_" + e)
chart = self.printer.config.get("Heaters", "temp_chart_" + e)
resistance = self.printer.config.getfloat("Heaters",
"resistance_" + e)
self.printer.thermistors[e] = Thermistor(adc, "MOSFET " + e, chart,
resistance)
self.printer.thermistors[e].printer = printer
# Extruders
onoff = self.printer.config.getboolean('Heaters', 'onoff_' + e)
prefix = self.printer.config.get('Heaters', 'prefix_' + e)
if e != "HBP":
self.printer.heaters[e] = Extruder(self.printer.steppers[e],
self.printer.thermistors[e],
self.printer.mosfets[e], e,
onoff)
else:
self.printer.heaters[e] = HBP(self.printer.thermistors[e],
self.printer.mosfets[e], onoff)
self.printer.heaters[e].prefix = prefix
self.printer.heaters[e].P = self.printer.config.getfloat(
'Heaters', 'pid_p_' + e)
self.printer.heaters[e].I = self.printer.config.getfloat(
'Heaters', 'pid_i_' + e)
self.printer.heaters[e].D = self.printer.config.getfloat(
'Heaters', 'pid_d_' + e)
# Min/max settings
self.printer.heaters[e].min_temp = self.printer.config.getfloat(
'Heaters', 'min_temp_' + e)
self.printer.heaters[e].max_temp = self.printer.config.getfloat(
'Heaters', 'max_temp_' + e)
self.printer.heaters[
e].max_temp_rise = self.printer.config.getfloat(
'Heaters', 'max_rise_temp_' + e)
self.printer.heaters[
e].max_temp_fall = self.printer.config.getfloat(
'Heaters', 'max_fall_temp_' + e)
# Init the three fans. Argument is PWM channel number
self.printer.fans = []
if self.revision == "00A3":
self.printer.fans.append(Fan(0))
self.printer.fans.append(Fan(1))
self.printer.fans.append(Fan(2))
elif self.revision == "0A4A":
self.printer.fans.append(Fan(8))
self.printer.fans.append(Fan(9))
self.printer.fans.append(Fan(10))
elif self.revision in ["00B1", "00B2", "00B3"]:
self.printer.fans.append(Fan(7))
self.printer.fans.append(Fan(8))
self.printer.fans.append(Fan(9))
self.printer.fans.append(Fan(10))
if printer.config.reach_revision == "00A0":
self.printer.fans.append(Fan(14))
self.printer.fans.append(Fan(15))
self.printer.fans.append(Fan(7))
# Disable all fans
for f in self.printer.fans:
f.set_value(0)
# Init the servos
printer.servos = []
servo_nr = 0
while (printer.config.has_option("Servos", "servo_" + str(servo_nr) +
"_enable")):
if printer.config.getboolean("Servos",
"servo_" + str(servo_nr) + "_enable"):
channel = printer.config.get(
"Servos", "servo_" + str(servo_nr) + "_channel")
pulse_min = printer.config.getfloat(
"Servos", "servo_" + str(servo_nr) + "_pulse_min")
pulse_max = printer.config.getfloat(
"Servos", "servo_" + str(servo_nr) + "_pulse_max")
angle_min = printer.config.getfloat(
"Servos", "servo_" + str(servo_nr) + "_angle_min")
angle_max = printer.config.getfloat(
"Servos", "servo_" + str(servo_nr) + "_angle_max")
angle_init = printer.config.getfloat(
"Servos", "servo_" + str(servo_nr) + "_angle_init")
s = Servo(channel, pulse_min, pulse_max, angle_min, angle_max,
angle_init)
printer.servos.append(s)
logging.info("Added servo " + str(servo_nr))
servo_nr += 1
# Connect thermitors to fans
for t, therm in self.printer.heaters.iteritems():
for f, fan in enumerate(self.printer.fans):
if not self.printer.config.has_option(
'Cold-ends', "connect-therm-{}-fan-{}".format(t, f)):
continue
if printer.config.getboolean(
'Cold-ends', "connect-therm-{}-fan-{}".format(t, f)):
c = Cooler(therm, fan, "Cooler-{}-{}".format(t, f),
True) # Use ON/OFF on these.
c.ok_range = 4
opt_temp = "therm-{}-fan-{}-target_temp".format(t, f)
if printer.config.has_option('Cold-ends', opt_temp):
target_temp = printer.config.getfloat(
'Cold-ends', opt_temp)
else:
target_temp = 60
c.set_target_temperature(target_temp)
c.enable()
printer.coolers.append(c)
logging.info("Cooler connects therm {} with fan {}".format(
t, f))
# Connect fans to M106
printer.controlled_fans = []
for i, fan in enumerate(self.printer.fans):
if not self.printer.config.has_option(
'Cold-ends', "add-fan-{}-to-M106".format(i)):
continue
if self.printer.config.getboolean('Cold-ends',
"add-fan-{}-to-M106".format(i)):
printer.controlled_fans.append(self.printer.fans[i])
logging.info("Added fan {} to M106/M107".format(i))
# Connect the colds to fans
for ce, cold_end in enumerate(self.printer.cold_ends):
for f, fan in enumerate(self.printer.fans):
option = "connect-ds18b20-{}-fan-{}".format(ce, f)
if self.printer.config.has_option('Cold-ends', option):
if self.printer.config.getboolean('Cold-ends', option):
c = Cooler(cold_end, fan,
"Cooler-ds18b20-{}-{}".format(ce, f), False)
c.ok_range = 4
opt_temp = "cooler_{}_target_temp".format(ce)
if printer.config.has_option('Cold-ends', opt_temp):
target_temp = printer.config.getfloat(
'Cold-ends', opt_temp)
else:
target_temp = 60
c.set_target_temperature(target_temp)
c.enable()
printer.coolers.append(c)
logging.info(
"Cooler connects temp sensor ds18b20 {} with fan {}"
.format(ce, f))
# Init roatray encs.
printer.filament_sensors = []
# Init rotary encoders
printer.rotary_encoders = []
for ex in ["E", "H", "A", "B", "C"]:
if not printer.config.has_option('Rotary-encoders',
"enable-{}".format(ex)):
continue
if printer.config.getboolean("Rotary-encoders",
"enable-{}".format(ex)):
logging.debug("Rotary encoder {} enabled".format(ex))
event = printer.config.get("Rotary-encoders",
"event-{}".format(ex))
cpr = printer.config.getint("Rotary-encoders",
"cpr-{}".format(ex))
diameter = printer.config.getfloat("Rotary-encoders",
"diameter-{}".format(ex))
r = RotaryEncoder(event, cpr, diameter)
printer.rotary_encoders.append(r)
# Append as Filament Sensor
ext_nr = Path.axis_to_index(ex) - 3
sensor = FilamentSensor(ex, r, ext_nr, printer)
alarm_level = printer.config.getfloat(
"Filament-sensors", "alarm-level-{}".format(ex))
logging.debug("Alarm level" + str(alarm_level))
sensor.alarm_level = alarm_level
printer.filament_sensors.append(sensor)
# Make a queue of commands
self.printer.commands = JoinableQueue(10)
# Make a queue of commands that should not be buffered
self.printer.sync_commands = JoinableQueue()
self.printer.unbuffered_commands = JoinableQueue(10)
# Bed compensation matrix
Path.matrix_bed_comp = printer.load_bed_compensation_matrix()
Path.matrix_bed_comp_inv = np.linalg.inv(Path.matrix_bed_comp)
logging.debug("Loaded bed compensation matrix: \n" +
str(Path.matrix_bed_comp))
for axis in printer.steppers.keys():
i = Path.axis_to_index(axis)
Path.max_speeds[i] = printer.config.getfloat(
'Planner', 'max_speed_' + axis.lower())
Path.min_speeds[i] = printer.config.getfloat(
'Planner', 'min_speed_' + axis.lower())
Path.jerks[i] = printer.config.getfloat('Planner',
'max_jerk_' + axis.lower())
Path.home_speed[i] = printer.config.getfloat(
'Homing', 'home_speed_' + axis.lower())
Path.home_backoff_speed[i] = printer.config.getfloat(
'Homing', 'home_backoff_speed_' + axis.lower())
Path.home_backoff_offset[i] = printer.config.getfloat(
'Homing', 'home_backoff_offset_' + axis.lower())
Path.steps_pr_meter[i] = printer.steppers[axis].get_steps_pr_meter(
)
Path.backlash_compensation[i] = printer.config.getfloat(
'Steppers', 'backlash_' + axis.lower())
dirname = os.path.dirname(os.path.realpath(__file__))
# Create the firmware compiler
pru_firmware = PruFirmware(dirname + "/firmware/firmware_runtime.p",
dirname + "/firmware/firmware_runtime.bin",
dirname + "/firmware/firmware_endstops.p",
dirname + "/firmware/firmware_endstops.bin",
self.printer, "/usr/bin/pasm")
printer.move_cache_size = printer.config.getfloat(
'Planner', 'move_cache_size')
printer.print_move_buffer_wait = printer.config.getfloat(
'Planner', 'print_move_buffer_wait')
printer.min_buffered_move_time = printer.config.getfloat(
'Planner', 'min_buffered_move_time')
printer.max_buffered_move_time = printer.config.getfloat(
'Planner', 'max_buffered_move_time')
self.printer.processor = GCodeProcessor(self.printer)
self.printer.plugins = PluginsController(self.printer)
# Path planner
travel_default = False
center_default = False
home_default = False
# Setting acceleration before PathPlanner init
for axis in printer.steppers.keys():
Path.acceleration[Path.axis_to_index(
axis)] = printer.config.getfloat(
'Planner', 'acceleration_' + axis.lower())
self.printer.path_planner = PathPlanner(self.printer, pru_firmware)
for axis in printer.steppers.keys():
i = Path.axis_to_index(axis)
# Sometimes soft_end_stop aren't defined to be at the exact hardware boundary.
# Adding 100mm for searching buffer.
if printer.config.has_option('Geometry', 'travel_' + axis.lower()):
printer.path_planner.travel_length[
axis] = printer.config.getfloat('Geometry',
'travel_' + axis.lower())
else:
printer.path_planner.travel_length[axis] = (
Path.soft_max[i] - Path.soft_min[i]) + .1
if axis in ['X', 'Y', 'Z']:
travel_default = True
if printer.config.has_option('Geometry', 'offset_' + axis.lower()):
printer.path_planner.center_offset[
axis] = printer.config.getfloat('Geometry',
'offset_' + axis.lower())
else:
printer.path_planner.center_offset[axis] = (
Path.soft_min[i]
if Path.home_speed[i] > 0 else Path.soft_max[i])
if axis in ['X', 'Y', 'Z']:
center_default = True
if printer.config.has_option('Homing', 'home_' + axis.lower()):
printer.path_planner.home_pos[axis] = printer.config.getfloat(
'Homing', 'home_' + axis.lower())
else:
printer.path_planner.home_pos[
axis] = printer.path_planner.center_offset[axis]
if axis in ['X', 'Y', 'Z']:
home_default = True
if Path.axis_config == Path.AXIS_CONFIG_DELTA:
if travel_default:
logging.warning(
"Axis travel (travel_*) set by soft limits, manual setup is recommended for a delta"
)
if center_default:
logging.warning(
"Axis offsets (offset_*) set by soft limits, manual setup is recommended for a delta"
)
if home_default:
logging.warning(
"Home position (home_*) set by soft limits or offset_*")
logging.info("Home position will be recalculated...")
# convert home_pos to effector space
Az = printer.path_planner.home_pos['X']
Bz = printer.path_planner.home_pos['Y']
Cz = printer.path_planner.home_pos['Z']
z_offset = Delta.vertical_offset(Az, Bz, Cz) # vertical offset
xyz = Delta.forward_kinematics2(Az, Bz,
Cz) # effector position
# The default home_pos, provided above, is based on effector space
# coordinates for carriage positions. We need to transform these to
# get where the effector actually is.
xyz[2] += z_offset
for i, a in enumerate(['X', 'Y', 'Z']):
printer.path_planner.home_pos[a] = xyz[i]
logging.info("Home position = %s" %
str(printer.path_planner.home_pos))
# Enable Stepper timeout
timeout = printer.config.getint('Steppers', 'timeout_seconds')
printer.swd = StepperWatchdog(printer, timeout)
if printer.config.getboolean('Steppers', 'use_timeout'):
printer.swd.start()
# Set up communication channels
printer.comms["USB"] = USB(self.printer)
printer.comms["Eth"] = Ethernet(self.printer)
if Pipe.check_tty0tty() or Pipe.check_socat():
printer.comms["octoprint"] = Pipe(printer, "octoprint")
printer.comms["toggle"] = Pipe(printer, "toggle")
printer.comms["testing"] = Pipe(printer, "testing")
printer.comms["testing_noret"] = Pipe(printer, "testing_noret")
# Does not send "ok"
printer.comms["testing_noret"].send_response = False
else:
logging.warning(
"Neither tty0tty or socat is installed! No virtual tty pipes enabled"
)
