#!/usr/bin/env python # -*- coding:UTF-8 -*- """ This file will control some options of the gmoccapy plasma screen and demonstrats at the same time the possibilities you have introducing your own handler files and functions to that screen, showing the possibilities to modify the layout and behavior Copyright 2013 Norbert Schechner nieson@web.de This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA Modified 12/16 to support my plasma tab JDM """ import math import hal_glib # needed to make our own hal pins import hal # needed to make our own hal pins from gladevcp.persistence import IniFile # we use this one to save the states of the widgets on shut down and restart from gladevcp.persistence import widget_defaults from gladevcp.persistence import select_widgets import gtk from gmoccapy import preferences from gmoccapy import getiniinfo class Plasma_TabClass: def __init__(self, halcomp, builder, useropts): self.builder = builder self.halcomp = halcomp self.defaults = { IniFile.vars : { "thcspeedval" : 15.0 , "thcspeedmax" : 100.0 , "thcspeedmin" : 1.0 , "thcspeedincr" : 1.0 , "cutgapval" : 0.06 , "cutgapmax" : 0.2 , "cutgapmin" : 0.01 , "cutgapincr" : 0.001 , "g0gapval" : 2.0 , "g0gapmax" : 4.5 , "g0gapmin" : 0.1 , "g0gapincr" : 0.1 , "pierceutostart" : True , "piercegapval" : .09 , "piercegapmax" : 0.5 , "piercegapmin" : 0.05 , "piercegapincr" : 0.001 , "piercedelayval" : 0.2 , "piercedelaymax" : 10.0 , "piercedelaymin" : 0.01 , "piercedelayincr" : 0.01 , "enableheightlock" : False, "chlthresholdmax" : 99.0, "chlthresholdmin" : 1.0 , "chlthresholdincr" : 1.0 , "chlthresholdval" : 80.0 , "thctargetvoltval" : 80.0, "thctargetvoltmax" : 255.0, "thctargetvoltmin" : 55.0 , "thctargetvoltincr" : 1.0 , "enablekerfcross" : False, "kerfcrossmax" : 500.0, "kerfcrossmin" : 10.0, "kerfcrossincr" : 10.0 , "kerfcrossval" : 90.0 , "enablethc" : False, "servodelayval" : 1.0 , "servodelaymax" : 10.0 , "servodelaymin" : 0.01 , "servodelayincr" : 0.01 , "thcvoltageset" : True, "rbtnvoltageset" : True, "rbtncontrolscrn": True, "rbtnfinecuts" : True, "lowpassfcval" : 40.0 }, } get_ini_info = getiniinfo.GetIniInfo() prefs = preferences.preferences(get_ini_info.get_preference_file_path()) theme_name = prefs.getpref("gtk_theme", "Follow System Theme", str) if theme_name == "Follow System Theme": theme_name = gtk.settings_get_default().get_property("gtk-theme-name") gtk.settings_get_default().set_string_property("gtk-theme-name", theme_name, "") self.ini_filename = __name__ + ".var" self.ini = IniFile(self.ini_filename, self.defaults, self.builder) self.ini.restore_state(self) # lets make our pins self.THC_speed = hal_glib.GPin(halcomp.newpin("THC-Speed", hal.HAL_FLOAT, hal.HAL_OUT)) self.z_max_velocity_in = hal_glib.GPin(halcomp.newpin("Z-Max-In",hal.HAL_FLOAT, hal.HAL_IN)) self.cut_gap = hal_glib.GPin(halcomp.newpin("cut-gap", hal.HAL_FLOAT, hal.HAL_OUT)) self.g0_gap = hal_glib.GPin(halcomp.newpin("g0-gap", hal.HAL_FLOAT, hal.HAL_OUT)) self.pierce_deley = hal_glib.GPin(halcomp.newpin("pierce-delay", hal.HAL_FLOAT, hal.HAL_OUT)) self.pierce_gap = hal_glib.GPin(halcomp.newpin("pierce-gap", hal.HAL_FLOAT, hal.HAL_OUT)) self.target_voltage = hal_glib.GPin(halcomp.newpin("Target-Voltage", hal.HAL_FLOAT, hal.HAL_OUT)) self.THC_enable_in = hal_glib.GPin(halcomp.newpin("THC-Enable-In", hal.HAL_BIT, hal.HAL_IN)) self.servo_delay = hal_glib.GPin(halcomp.newpin("servo-delay", hal.HAL_FLOAT, hal.HAL_OUT)) self.thc_voltage_mode = hal_glib.GPin(halcomp.newpin("thc-voltage-mode", hal.HAL_BIT, hal.HAL_OUT)) self.use_machine_params = hal_glib.GPin(halcomp.newpin("use_control_params", hal.HAL_BIT, hal.HAL_OUT)) self.use_finecuts = hal_glib.GPin(halcomp.newpin("use-finecuts", hal.HAL_BIT, hal.HAL_OUT)) self.lowpassfc = hal_glib.GPin(halcomp.newpin("Lowpass-Fc", hal.HAL_FLOAT, hal.HAL_OUT)) self.lowpasslingain = hal_glib.GPin(halcomp.newpin("Lowpass-Lin-Gain", hal.HAL_FLOAT, hal.HAL_OUT)) #input for control codes from gcode file (M67 E0 & M68 E0) self.command_from_file = hal_glib.GPin(halcomp.newpin("Command-From-File", hal.HAL_FLOAT, hal.HAL_IN)) self.lock_height = hal_glib.GPin(halcomp.newpin("Lock-Height-From-File", hal.HAL_BIT, hal.HAL_OUT)) #new local pins for corner hold threshold link to main screen and HAL self.CHLD_threshold = hal_glib.GPin(halcomp.newpin("CHL-Threshold", hal.HAL_FLOAT, hal.HAL_OUT)) self.chld_threshold = hal_glib.GPin(halcomp.newpin("CHLD-Threshold-In",hal.HAL_FLOAT,hal.HAL_IN)) self.enbl_heightlock = hal_glib.GPin(halcomp.newpin("Enbl-Heightlock-In",hal.HAL_BIT, hal.HAL_IN)) #self.requested-vel = hal_glib.GPin(halcomp.newpin("Requested-Vel-In",hal.HAL_FLOAT, hal.HAL_IN)) #new local pins for kerf crossing link to main screen and HAL self.kerf_threshold = hal_glib.GPin(halcomp.newpin("Kerf-Threshold-In",hal.HAL_FLOAT,hal.HAL_IN)) self.enbl_kerf_crossing = hal_glib.GPin(halcomp.newpin("Enbl-Kerf-Crossing",hal.HAL_BIT, hal.HAL_IN)) #these local input hal pins receive inputs from nets in plasma.hal self.btn_press_minus_THC = hal_glib.GPin(halcomp.newpin("THC-Minus-Button", hal.HAL_BIT, hal.HAL_IN)) self.btn_press_plus_THC = hal_glib.GPin(halcomp.newpin("THC-Plus-Button", hal.HAL_BIT, hal.HAL_IN)) #end of local input hal pins #need to do this to synch up initial state self.halcomp["thc-voltage-mode"] = True self.halcomp["use_control_params"] = True # get all widgets and connect them self.lbl_prog_volt = self.builder.get_object("lbl_prog_volt") self.lbl_cut_speed = self.builder.get_object("lbl_cut_speed") self.lbl_cut_gap = self.builder.get_object("lbl_cut_gap") self.lbl_g0_gap = self.builder.get_object("lbl_g0_gap") self.lbl_pierce_gap = self.builder.get_object("lbl_pierce_gap") self.lbl_pierce_delay = self.builder.get_object("lbl_pierce_delay") self.lbl_servo_delay = self.builder.get_object("lbl_servo_delay") self.btn_THC_speed_minus = self.builder.get_object("btn_THC_speed_minus") self.btn_THC_speed_minus.connect("pressed", self.on_btn_THC_speed_pressed, -1) self.btn_THC_speed_plus = self.builder.get_object("btn_THC_speed_plus") self.btn_THC_speed_plus.connect("pressed", self.on_btn_THC_speed_pressed, 1) self.adj_THC_speed = self.builder.get_object("adj_THC_speed") self.adj_THC_speed.connect("value_changed", self.on_adj_THC_speed_value_changed) self.adj_THC_speed.upper = self.thcspeedmax self.adj_THC_speed.lower = self.thcspeedmin self.adj_THC_speed.set_value(self.thcspeedval) self.btn_cut_gap_minus = self.builder.get_object("btn_cut_gap_minus") self.btn_cut_gap_minus.connect("pressed", self.on_btn_cut_gap_pressed, -1) self.btn_cut_gap_plus = self.builder.get_object("btn_cut_gap_plus") self.btn_cut_gap_plus.connect("pressed", self.on_btn_cut_gap_pressed, 1) self.adj_cut_gap = self.builder.get_object("adj_cut_gap") self.adj_cut_gap.connect("value_changed", self.on_adj_cut_gap_value_changed) self.adj_cut_gap.upper = self.cutgapmax self.adj_cut_gap.lower = self.cutgapmin self.adj_cut_gap.set_value(self.cutgapval) self.btn_g0_minus = self.builder.get_object("btn_g0_minus") self.btn_g0_minus.connect("pressed", self.on_btn_g0_pressed, -1) self.btn_g0_plus = self.builder.get_object("btn_g0_plus") self.btn_g0_plus.connect("pressed", self.on_btn_g0_pressed, 1) self.adj_G0_gap = self.builder.get_object("adj_G0_gap") self.adj_G0_gap.connect("value_changed", self.on_adj_G0_gap_value_changed) self.adj_G0_gap.upper = self.g0gapmax self.adj_G0_gap.lower = self.g0gapmin self.adj_G0_gap.set_value(self.g0gapval) self.Piercing_autostart = self.builder.get_object("piercing-autostart") self.Piercing_autostart.connect("toggled", self.on_Piercing_autostart_toggled) self.Piercing_autostart.set_active(self.pierceutostart) self.btn_pierce_gap_minus = self.builder.get_object("btn_pierce_gap_minus") self.btn_pierce_gap_minus.connect("pressed", self.on_btn_pierce_gap_pressed, -1) self.btn_pierce_gap_plus = self.builder.get_object("btn_pierce_gap_plus") self.btn_pierce_gap_plus.connect("pressed", self.on_btn_pierce_gap_pressed, 1) self.adj_pierce_gap = self.builder.get_object("adj_pierce_gap") self.adj_pierce_gap.connect("value_changed", self.on_adj_pierce_gap_value_changed) self.adj_pierce_gap.upper = self.piercegapmax self.adj_pierce_gap.lower = self.piercegapmin self.adj_pierce_gap.set_value(self.piercegapval) self.btn_pierce_delay_minus = self.builder.get_object("btn_pierce_delay_minus") self.btn_pierce_delay_minus.connect("pressed", self.on_btn_pierce_delay_pressed, -1) self.btn_pierce_delay_plus = self.builder.get_object("btn_pierce_delay_plus") self.btn_pierce_delay_plus.connect("pressed", self.on_btn_pierce_delay_pressed, 1) self.adj_pierce_delay = self.builder.get_object("adj_pierce_delay") self.adj_pierce_delay.connect("value_changed", self.on_adj_pierce_delay_value_changed) self.adj_pierce_delay.upper = self.piercedelaymax self.adj_pierce_delay.lower = self.piercedelaymin self.adj_pierce_delay.set_value(self.piercedelayval) self.btn_servo_delay_minus = self.builder.get_object("btn_servo_delay_minus") self.btn_servo_delay_minus.connect("pressed", self.on_btn_servo_delay_pressed, -1) self.btn_servo_delay_plus = self.builder.get_object("btn_servo_delay_plus") self.btn_servo_delay_plus.connect("pressed", self.on_btn_servo_delay_pressed, 1) self.adj_servo_delay = self.builder.get_object("adj_servo_delay") self.adj_servo_delay.connect("value_changed", self.on_adj_servo_delay_value_changed) self.adj_servo_delay.upper = self.servodelaymax self.adj_servo_delay.lower = self.servodelaymin self.adj_servo_delay.set_value(self.servodelayval) self.enable_HeightLock = self.builder.get_object("enable-HeightLock") self.enable_HeightLock.connect("toggled", self.on_enable_HeightLock_toggled) self.enable_HeightLock.set_active(self.enableheightlock) self.adj_CHL_threshold = self.builder.get_object("adj_CHL_threshold") self.adj_CHL_threshold.connect("value_changed", self.on_adj_CHL_threshold_value_changed) # self.adj_CHL_threshold.upper = self.chlthresholdmax # self.adj_CHL_threshold.lower = self.chlthresholdmin self.adj_CHL_threshold.set_value(self.chlthresholdval) self.btn_THC_target_minus = self.builder.get_object("btn_THC_target_minus") self.btn_THC_target_minus.connect("pressed", self.on_btn_THC_target_pressed, -1) self.btn_THC_target_plus = self.builder.get_object("btn_THC_target_plus") self.btn_THC_target_plus.connect("pressed", self.on_btn_THC_target_pressed, 1) self.adj_THC_Voltage = self.builder.get_object("adj_THC_Voltage") self.adj_THC_Voltage.connect("value_changed", self.on_adj_THC_Voltage_value_changed) self.adj_THC_Voltage.upper = self.thctargetvoltmax self.adj_THC_Voltage.lower = self.thctargetvoltmin self.adj_THC_Voltage.set_value(self.thctargetvoltval) self.enable_kerf_crossing = self.builder.get_object("enable-kerf-crossing") self.enable_kerf_crossing.connect("toggled", self.on_enable_kerf_crossing_toggled) self.enable_kerf_crossing.set_active(self.enablekerfcross) self.adj_kerf_threshold = self.builder.get_object("adj_kerf_threshold") self.adj_kerf_threshold.connect("value_changed", self.on_adj_kerf_threshold_value_changed) # self.adj_kerf_threshold.upper = self.kerfcrossmax # self.adj_kerf_threshold.lower = self.kerfcrossmin self.adj_kerf_threshold.set_value(self.kerfcrossval) self.enable_THC_tab = self.builder.get_object("hal-btn-THC") self.enable_THC_tab.connect("toggled",self.on_enable_THC_toggled) self.enable_THC_tab.set_active(self.enablethc) self.enable_thc_voltage_set = self.builder.get_object("rad-btn-voltage_set") self.enable_thc_voltage_set.connect("toggled", self.on_rbtn_voltage_set_toggled) self.enable_thc_voltage_set.set_active(self.rbtnvoltageset) self.enable_use_machine_params = self.builder.get_object("rbtn_control_scrn") self.enable_use_machine_params.connect("toggled", self.on_rbtn_control_scrn_toggled) self.enable_use_machine_params.set_active(self.rbtncontrolscrn) self.enable_use_finecuts = self.builder.get_object("rbtn_finecut") self.enable_use_finecuts.connect("toggled", self.on_rbtn_finecuts_toggled) self.enable_use_finecuts.set_active(self.rbtnfinecuts) self.adj_lowpass_fc = self.builder.get_object("adj-lowpass-fc") self.adj_lowpass_fc.connect("value_changed", self.on_adj_lowpass_fc_value_changed) self.adj_lowpass_fc.set_value(self.lowpassfcval) #these are the connections to local hal pins connected to nets in plasma.hal self.btn_press_minus_THC.connect("value-changed", self._on_btn_THC_target_pressed, -1) self.btn_press_plus_THC.connect("value-changed", self._on_btn_THC_target_pressed, 1) #service value change on hal input pin self.enbl_heightlock.connect("value-changed", self._on_enable_HeightLock_toggled) # self.enable_HeightLock.set_active(self.enableheightlock) self.chld_threshold.connect("value-changed", self._on_adj_CHL_threshold_value_changed) # self.adj_CHL_threshold.set_value(self.chlthresholdval) #service value change on hal input pins for kerf crossing synch with main page self.enbl_kerf_crossing.connect("value-changed", self._on_enable_kerf_crossing_toggled) # self.enable_kerf_crossing.set_active(self.enablekerfcross) self.kerf_threshold.connect("value-changed",self._on_adj_kerf_threshold_value_changed) # self.adj_kerf_threshold.set_value(self.kerfcrossval) #service THC enable from change on hal input pin self.THC_enable_in.connect("value-changed", self._on_enable_THC_toggled) #service command from gcode self.command_from_file.connect("value-changed", self.on_new_command_from_file) #end of local hal pin connections #this must stay with the _on_destroy definition self.tbl_cutting = self.builder.get_object("tbl_cutting") self.tbl_cutting.connect("destroy", self._on_destroy) def _on_destroy(self, obj, data = None): self.ini.save_state(self) # What to do on button pres events? def on_btn_THC_speed_pressed(self, widget, dir): increment = self.thcspeedincr * dir self.thcspeedval = self.adj_THC_speed.get_value() + increment self.adj_THC_speed.set_value(self.thcspeedval) def on_btn_cut_gap_pressed(self, widget, dir): increment = self.cutgapincr * dir self.cutgapval = self.adj_cut_gap.get_value() + increment self.adj_cut_gap.set_value(self.cutgapval) def on_btn_g0_pressed(self, widget, dir): increment = self.g0gapincr * dir self.g0gapval = self.adj_G0_gap.get_value() + increment self.adj_G0_gap.set_value(self.g0gapval) def on_btn_pierce_gap_pressed(self, widget, dir): increment = self.piercegapincr * dir self.piercegapval = self.adj_pierce_gap.get_value() + increment self.adj_pierce_gap.set_value(self.piercegapval) def on_btn_pierce_delay_pressed(self, widget, dir): increment = self.piercedelayincr * dir self.piercedelayval = self.adj_pierce_delay.get_value() + increment self.adj_pierce_delay.set_value(self.piercedelayval) def on_btn_servo_delay_pressed(self, widget, dir): increment = self.servodelayincr * dir self.servodelayval = self.adj_servo_delay.get_value() + increment self.adj_servo_delay.set_value(self.servodelayval) def on_btn_THC_target_pressed(self, widget, dir): increment = self.thctargetvoltincr * dir self.thctargetvoltval = self.adj_THC_Voltage.get_value() + increment self.adj_THC_Voltage.set_value(self.thctargetvoltval) #realy don't know why but this is what I had to do to make controls work from main panel def _on_btn_THC_target_pressed(self, hal_pin, dir): if hal_pin.get() == True: increment = self.thctargetvoltincr * dir self.thctargetvoltval = self.adj_THC_Voltage.get_value() + increment self.adj_THC_Voltage.set_value(self.thctargetvoltval) # use radio button to set thc voltage mode def on_rbtn_voltage_set_toggled(self, widget, data = None): self.halcomp["thc-voltage-mode"] = widget.get_active() # use radio button to set cutting param source def on_rbtn_control_scrn_toggled(self, widget, data = None): self.halcomp["use_control_params"] = widget.get_active() # use radio button to set consumables used def on_rbtn_finecuts_toggled(self, widget, data = None): self.halcomp["use-finecuts"] = widget.get_active() # and the behavior of the adjustments to control max and min values def on_adj_THC_speed_value_changed(self, widget, data = None): if widget.get_value() >= widget.upper: self.btn_THC_speed_plus.set_sensitive(False) elif widget.get_value() <= widget.lower: self.btn_THC_speed_minus.set_sensitive(False) else: self.btn_THC_speed_plus.set_sensitive(True) self.btn_THC_speed_minus.set_sensitive(True) # self.THC_speed = widget.get_value() * self.z_max_velocity_in self.halcomp["THC-Speed"] = widget.get_value() * .01 self.lbl_cut_speed.set_label("%.1f" % (widget.get_value())) def on_adj_cut_gap_value_changed(self, widget, data = None): if widget.get_value() >= widget.upper: self.btn_cut_gap_plus.set_sensitive(False) elif widget.get_value() <= widget.lower: self.btn_cut_gap_minus.set_sensitive(False) else: self.btn_cut_gap_plus.set_sensitive(True) self.btn_cut_gap_minus.set_sensitive(True) self.halcomp["cut-gap"] = widget.get_value() self.lbl_cut_gap.set_label("%.3f" % (widget.get_value())) def on_adj_G0_gap_value_changed(self, widget, data = None): if widget.get_value() >= widget.upper: self.btn_g0_plus.set_sensitive(False) elif widget.get_value() <= widget.lower: self.btn_g0_minus.set_sensitive(False) else: self.btn_g0_plus.set_sensitive(True) self.btn_g0_minus.set_sensitive(True) self.halcomp["g0-gap"] = widget.get_value() self.lbl_g0_gap.set_label("%.3f" % (widget.get_value())) def on_adj_pierce_gap_value_changed(self, widget, data = None): if widget.get_value() >= widget.upper: self.btn_pierce_gap_plus.set_sensitive(False) elif widget.get_value() <= widget.lower: self.btn_pierce_gap_minus.set_sensitive(False) else: self.btn_pierce_gap_plus.set_sensitive(True) self.btn_pierce_gap_minus.set_sensitive(True) self.halcomp["pierce-gap"] = widget.get_value() self.lbl_pierce_gap.set_label("%.3f" % (widget.get_value())) def on_adj_pierce_delay_value_changed(self, widget, data = None): if widget.get_value() >= widget.upper: self.btn_pierce_delay_plus.set_sensitive(False) elif widget.get_value() <= widget.lower: self.btn_pierce_delay_minus.set_sensitive(False) else: self.btn_pierce_delay_plus.set_sensitive(True) self.btn_pierce_delay_minus.set_sensitive(True) self.halcomp["pierce-delay"] = widget.get_value() self.lbl_pierce_delay.set_label("%.2f" % (widget.get_value())) def on_adj_servo_delay_value_changed(self, widget, data = None): if widget.get_value() >= widget.upper: self.btn_servo_delay_plus.set_sensitive(False) elif widget.get_value() <= widget.lower: self.btn_servo_delay_minus.set_sensitive(False) else: self.btn_servo_delay_plus.set_sensitive(True) self.btn_servo_delay_minus.set_sensitive(True) self.halcomp["servo-delay"] = widget.get_value() self.lbl_servo_delay.set_label("%.2f" % (widget.get_value())) def on_adj_CHL_threshold_value_changed(self, widget, data = None): self.chlthresholdval = widget.get_value() self.halcomp["CHL-Threshold"] = widget.get_value() * .01 #this function is used if adjustment value is modified from GUI def on_adj_lowpass_fc_value_changed(self, widget, data = None): self.lowpassfcval = widget.get_value() self.halcomp["Lowpass-Fc"] = widget.get_value() # a = 2*3.141592*self.lowpassfcval a = 2*math.pi*self.lowpassfcval # self.halcomp["Lowpass-Lin-Gain"] = 1 - 2.718281**(-a * .001) self.halcomp["Lowpass-Lin-Gain"] = 1 - math.e**(-a * .001) #this function is used if adjustment value is modified from hal def _on_adj_CHL_threshold_value_changed(self, hal_pin, data = None): # self.chlthresholdval = hal_pin.get() # self.adj_CHL_threshold.set_value( self.chlthresholdval) if hal_pin.get() != self.adj_CHL_threshold.get_value(): self.adj_CHL_threshold.upper = self.chlthresholdmax self.adj_CHL_threshold.lower = self.chlthresholdmin self.chlthresholdval = hal_pin.get() self.adj_CHL_threshold.set_value(hal_pin.get()) def on_adj_kerf_threshold_value_changed(self, widget, data = None): self.kerfcrossval = widget.get_value() #this function is used if adjustment value is modified from HAL def _on_adj_kerf_threshold_value_changed(self,hal_pin, data = None): # self.kerfcrossval = hal_pin.get() # self.adj_kerf_threshold.set_value(self.kerfcrossval) if hal_pin.get() != self.adj_kerf_threshold.get_value(): self.adj_kerf_threshold.upper = self.kerfcrossmax self.adj_kerf_threshold.lower = self.kerfcrossmin self.kerfcrossval = hal_pin.get() self.adj_kerf_threshold.set_value(hal_pin.get()) def on_adj_THC_Voltage_value_changed(self, widget, data = None): if widget.get_value() >= widget.upper: self.btn_THC_target_plus.set_sensitive(False) elif widget.get_value() <= widget.lower: self.btn_THC_target_minus.set_sensitive(False) else: self.btn_THC_target_plus.set_sensitive(True) self.btn_THC_target_minus.set_sensitive(True) self.halcomp["Target-Voltage"] = widget.get_value() self.lbl_prog_volt.set_label("%d" % (widget.get_value())) def on_Piercing_autostart_toggled(self, widget, data = None): self.pierceutostart = widget.get_active() def on_enable_HeightLock_toggled(self, widget, data = None): self.enableheightlock = widget.get_active() #this function is used if enable is toggle from hal def _on_enable_HeightLock_toggled(self, hal_pin, data = None): # self.enableheightlock = hal_pin.get() # self.enable_HeightLock.set_active(self.enableheightlock) if hal_pin.get() != self.enable_HeightLock.get_active(): self.enable_HeightLock.set_active(hal_pin.get()) # else: # self.enable_HeightLock.set_active(False) def on_enable_kerf_crossing_toggled(self, widget, data = None): self.enablekerfcross = widget.get_active() #this function is used if enable is toggled from HAL def _on_enable_kerf_crossing_toggled(self, hal_pin, data = None): # self.enablekerfcross = hal_pin.get() # self.enable_kerf_crossing.set_active(self.enablekerfcross) if hal_pin.get() != self.enable_kerf_crossing.get_active(): self.enable_kerf_crossing.set_active(hal_pin.get()) # else: # self.enable_kerf_crossing.set_active(False) def on_enable_THC_toggled(self, widget, data = None): self.enablethc = widget.get_active() #this function is used if THC enable is toggled from hal def _on_enable_THC_toggled(self, hal_pin, data = None): if hal_pin.get() != self.enable_THC_tab.get_active(): self.enable_THC_tab.set_active(hal_pin.get()) #this function is used to decode command from gcode file # if real time control of height hold is desired then 1X and 2X need to be # decoded in a realtime component def on_new_command_from_file(self, hal_pin, data = None): if hal_pin.get() != 0: command = hal_pin.get() #THC run from file if 20 <= command < 30: self.halcomp["Lock-Height-From-File"] = False #no need to decode I% here no Hypertherm RS-485 # height hold from file elif 10 <= command < 20: self.halcomp["Lock-Height-From-File"] = True #no need to decode I% here no Hypertherm RS-485 #global THC on elif 900 == command: if self.rbtncontrolscrn != True: self.enablethc = True self.enable_THC_tab.set_active(self.enablethc) # global THC off elif 999 == command: if self.rbtncontrolscrn != True: self.enablethc = False self.enable_THC_tab.set_active(self.enablethc) #get arc voltage elif 360 <= command < 400 or 3060 <= command < 3201: if command >= 3060: command = command - 3000 else: command = command - 300 if self.rbtncontrolscrn != True: self.adj_THC_Voltage.set_value(command) #get preset Amps not actually used elif 410 <= command < 500 or 4000 <= command < 4201: if command >= 4000: command = command - 4000 else: command = command - 400 #nothing else to do here for now #get arc servo delay time elif 50 <= command < 60 or 500 <= command < 600: if command >= 500: command = (command - 500)/10 else: command = command - 50 if self.rbtncontrolscrn != True: self.adj_servo_delay.set_value(command) #get THC tune elif 710 <= command < 720: command = command - 710 #nothing to set yet def get_handlers(halcomp, builder, useropts): return[Plasma_TabClass(halcomp, builder, useropts)]