wangdequan/linuxcncAllWasm
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
d4dec05c37de87e36e43093ecf548f397382c651
linuxcncAllWasm/lib/python/gladevcp/combi_dro.py
Wang Dequan 2c814634c3 Import LinuxCNC source tree
2026-08-20 06:17:39 +08:00

729 lines
30 KiB
Python
Raw Blame History

#!/usr/bin/env python3
# GladeVcp Widget - DRO widget, showing all 3 reference types
# This widgets displays linuxcnc axis position information.
#
# Copyright (c) 2013 Norbert Schechner
# Based on the drowidget from Chris Morley
#
# 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.
import gi
gi.require_version("Gtk","3.0")
gi.require_version("Gdk","3.0")
from gi.repository import Gtk
from gi.repository import Gdk
from gi.repository import GObject
from gi.repository import Pango
from gi.repository import GLib
import os
import sys
import math
import linuxcnc
from gladevcp.core import Status as GStat
import re
# constants
_INCH = 0
_MM = 1
_AXISLETTERS = ["X", "Y", "Z", "A", "B", "C", "U", "V", "W"]
# we put this in a try so there is no error in the glade editor
# linuxcnc is probably not running then
try:
INIPATH = os.environ['INI_FILE_NAME']
except:
# INIPATH = '/home/emcmesa/linuxcnc-dev/configs/sim/gmoccapy/gmoccapy.ini'
pass
# This is the main class
class Combi_DRO(Gtk.Box):
'''
Combi_DRO will display an linuxcnc DRO with all three types at ones
Combi_DRO = Combi_DRO(joint_number)
joint_number is an integer in the range from 0 to 8
where 0 = X, 1 = Y, 2 = Z, etc.
'''
__gtype_name__ = 'Combi_DRO'
__gproperties__ = {
'joint_number' : (GObject.TYPE_INT, 'Joint Number', '0:X 1:Y 2:Z etc',
0, 8, 0, GObject.ParamFlags.READWRITE | GObject.ParamFlags.CONSTRUCT),
'actual' : (GObject.TYPE_BOOLEAN, 'Actual Position', 'Display Actual or Commanded Position',
True, GObject.ParamFlags.READWRITE | GObject.ParamFlags.CONSTRUCT),
'metric_units' : (GObject.TYPE_BOOLEAN, 'Display in metric units', 'Display in metric or not',
True, GObject.ParamFlags.READWRITE | GObject.ParamFlags.CONSTRUCT),
'auto_units' : (GObject.TYPE_BOOLEAN, 'Change units according gcode', 'Units will toggle between metric and imperial according to gcode.',
True, GObject.ParamFlags.READWRITE | GObject.ParamFlags.CONSTRUCT),
'diameter' : (GObject.TYPE_BOOLEAN, 'Diameter Adjustment', 'Display Position As Diameter',
False, GObject.ParamFlags.READWRITE | GObject.ParamFlags.CONSTRUCT),
'mm_text_template' : (GObject.TYPE_STRING, 'Text template for Metric Units',
'Text template to display. Python formatting may be used for one variable',
"%10.3f", GObject.ParamFlags.READWRITE | GObject.ParamFlags.CONSTRUCT),
'imperial_text_template' : (GObject.TYPE_STRING, 'Text template for Imperial Units',
'Text template to display. Python formatting may be used for one variable',
"%9.4f", GObject.ParamFlags.READWRITE | GObject.ParamFlags.CONSTRUCT),
'homed_color' : (Gdk.RGBA.__gtype__, 'homed color', 'Sets the color of the display when the axis is homed',
GObject.ParamFlags.READWRITE),
'unhomed_color' : (Gdk.RGBA.__gtype__, 'unhomed color', 'Sets the color of the display when the axis is not homed',
GObject.ParamFlags.READWRITE),
'abs_color' : (Gdk.RGBA.__gtype__, 'Absolute color', 'Sets the color of the display when absolute coordinates are used',
GObject.ParamFlags.READWRITE),
'rel_color' : (Gdk.RGBA.__gtype__, 'Relative color', 'Sets the color of the display when relative coordinates are used',
GObject.ParamFlags.READWRITE),
'dtg_color' : (Gdk.RGBA.__gtype__, 'DTG color', 'Sets the color of the display when dtg coordinates are used',
GObject.ParamFlags.READWRITE),
'font_size' : (GObject.TYPE_INT, 'Font Size', 'The font size of the big numbers, the small ones will be 2.5 times smaller',
8, 96, 25, GObject.ParamFlags.READWRITE | GObject.ParamFlags.CONSTRUCT),
'toggle_readout' : (GObject.TYPE_BOOLEAN, 'Enable toggling readout with click', 'The DRO will toggle between Absolute, Relative and DTG with each mouse click.',
True, GObject.ParamFlags.READWRITE | GObject.ParamFlags.CONSTRUCT),
'cycle_time' : (GObject.TYPE_INT, 'Cycle Time', 'Time, in milliseconds, that display will sleep between polls',
100, 1000, 150, GObject.ParamFlags.READWRITE | GObject.ParamFlags.CONSTRUCT),
}
__gproperties = __gproperties__
__gsignals__ = {
'clicked': (GObject.SignalFlags.RUN_FIRST, GObject.TYPE_NONE, (GObject.TYPE_STRING, GObject.TYPE_PYOBJECT)),
'units_changed': (GObject.SignalFlags.RUN_FIRST, GObject.TYPE_NONE, (GObject.TYPE_BOOLEAN,)),
'system_changed': (GObject.SignalFlags.RUN_FIRST, GObject.TYPE_NONE, (GObject.TYPE_STRING,)),
'axis_clicked': (GObject.SignalFlags.RUN_FIRST, GObject.TYPE_NONE, (GObject.TYPE_STRING,)),
'exit': (GObject.SignalFlags.RUN_FIRST, GObject.TYPE_NONE, ()),
}
# Init the class
def __init__(self, joint_number = 0):
super(Combi_DRO, self).__init__()
self.set_orientation(Gtk.Orientation.VERTICAL)
# we have to distinguish this, as we use the joints number to check homing
# and we do need the axis to check for the positions
# this is needed if non trivial kinematics are used or just a lathe,
# as the lathe has only two joints, but Z will be the third value in position feedback
self.axis_no = self.joint_number = joint_number
# get the necessary connections to linuxcnc
self.linuxcnc = linuxcnc
self.status = linuxcnc.stat()
self.gstat = GStat()
# set some default values'
self._ORDER = ["Rel", "Abs", "DTG"]
self.system = "Rel"
self.homed = False
self.homed_color = "#00FF00"
self.unhomed_color = "#FF0000"
self.abs_color = "#0000FF"
self.rel_color = "#000000"
self.dtg_color = "#FFFF00"
self.mm_text_template = "%10.3f"
self.imperial_text_template = "%9.4f"
self.font_size = 25
self.metric_units = True
self.machine_units = _MM
self.unit_convert = 1
self._auto_units = True
self.toggle_readout_enable = True
self.cycle_time = 150
self.diameter = False
self.actual = True
self.dtg = 0
self.abs_pos = 0
self.rel_pos = 0
self.margin_left = 5
self.margin_right = 5
self.widgets = {} # will hold all our widgets we need to style
# Make the GUI and connect signals
self.css_text = """
.background {background-color: #000000;}
.labelcolor {color: #FF0000;}
.size_big {font-size: 25px;font-weight: bold;}
.size_small {font-size: 10px;font-weight: bold;}
"""
self.css = Gtk.CssProvider()
self.css.load_from_data(bytes(self.css_text, 'utf-8'))
eventbox = Gtk.EventBox()
eventbox.get_style_context().add_provider(self.css,Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
eventbox.get_style_context().add_class('background')
self.add(eventbox)
vbox_main = Gtk.Box(homogeneous = False, spacing = 0)
vbox_main.set_orientation(Gtk.Orientation.VERTICAL)
eventbox.add(vbox_main)
hbox_up = Gtk.Box(homogeneous = False, spacing = 5)
hbox_up.get_style_context().add_provider(self.css,Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
hbox_up.get_style_context().add_class('background')
vbox_main.pack_start(hbox_up, True, True, 0)
vbox_main.set_margin_start(self.margin_left)
vbox_main.set_margin_end(self.margin_right)
self.widgets["hbox_up"] = hbox_up
self.widgets["eventbox"] = eventbox
lbl_axisletter = Gtk.Label(label = _AXISLETTERS[self.axis_no])
lbl_axisletter.get_style_context().add_provider(self.css,Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
lbl_axisletter.get_style_context().add_class('background')
lbl_axisletter.get_style_context().add_class('labelcolor')
lbl_axisletter.get_style_context().add_class('size_big')
hbox_up.pack_start(lbl_axisletter, False, False, 0)
self.widgets["lbl_axisletter"] = lbl_axisletter
vbox_ref_type = Gtk.Box(homogeneous = False, spacing = 0)
vbox_ref_type.set_orientation(Gtk.Orientation.VERTICAL)
hbox_up.pack_start(vbox_ref_type, False, False, 0)
# This label is needed to press the main index (rel,Abs;Dtg) to the upper part
lbl_space = Gtk.Label(label = "")
vbox_ref_type.pack_start(lbl_space, True, True, 0)
lbl_sys_main = Gtk.Label(label = self.system)
lbl_sys_main.get_style_context().add_provider(self.css,Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
lbl_sys_main.get_style_context().add_class('background')
lbl_sys_main.get_style_context().add_class('labelcolor')
lbl_sys_main.get_style_context().add_class("size_small")
vbox_ref_type.pack_start(lbl_sys_main, False, False, 0)
self.widgets["lbl_sys_main"] = lbl_sys_main
main_dro = Gtk.Label(label = "9999.999")
main_dro.get_style_context().add_provider(self.css,Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
main_dro.get_style_context().add_class('background')
main_dro.get_style_context().add_class('labelcolor')
main_dro.get_style_context().add_class("size_big")
main_dro.set_xalign(1.0)
hbox_up.pack_start(main_dro, True, True, 0)
self.widgets["main_dro"] = main_dro
hbox_down = Gtk.Box(homogeneous = True, spacing = 5)
vbox_main.pack_start(hbox_down, False, False, 0)
lbl_sys_left = Gtk.Label(label = "Abs")
lbl_sys_left.set_xalign(0.0)
lbl_sys_left.get_style_context().add_provider(self.css,Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
lbl_sys_left.get_style_context().add_class('background')
lbl_sys_left.get_style_context().add_class('labelcolor')
lbl_sys_left.get_style_context().add_class('size_small')
hbox_down.pack_start(lbl_sys_left, True, True, 0)
self.widgets["lbl_sys_left"] = lbl_sys_left
dro_left = Gtk.Label(label = "-11.111")
dro_left.get_style_context().add_provider(self.css,Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
dro_left.get_style_context().add_class('background')
dro_left.get_style_context().add_class('labelcolor')
dro_left.get_style_context().add_class('size_small')
dro_left.set_xalign(1.0)
hbox_down.pack_start(dro_left, True, True, 0)
self.widgets["dro_left"] = dro_left
lbl_sys_right = Gtk.Label(label = "DTG")
lbl_sys_right.set_xalign(0.0)
lbl_sys_right.get_style_context().add_provider(self.css,Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
lbl_sys_right.get_style_context().add_class('background')
lbl_sys_right.get_style_context().add_class('labelcolor')
lbl_sys_right.get_style_context().add_class('size_small')
hbox_down.pack_start(lbl_sys_right, False, False, 0)
self.widgets["lbl_sys_right"] = lbl_sys_right
dro_right = Gtk.Label(label = "22.222")
dro_right.get_style_context().add_provider(self.css,Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
dro_right.get_style_context().add_class('background')
dro_right.get_style_context().add_class('labelcolor')
dro_right.get_style_context().add_class('size_small')
dro_right.set_xalign(1.0)
hbox_down.pack_start(dro_right, True, True, 0)
self.widgets["dro_right"] = dro_right
eventbox.connect("button_press_event", self._on_eventbox_clicked)
self.show_all()
self.gstat.connect('not-all-homed', self._not_all_homed )
self.gstat.connect('all-homed', self._all_homed )
self.gstat.connect('homed', self._homed )
self.gstat.connect('current-position', self._position)
self.gstat.connect('user-system-changed', self._user_system_changed)
self._set_labels()
# This try is only needed because while working with glade
# linuxcnc may not be working
try:
self.inifile = self.linuxcnc.ini(INIPATH)
# check the INI file if UNITS are set to mm"
# first check the global settings
units = self.inifile.find("TRAJ", "LINEAR_UNITS")
if units == None:
# else then the X axis units
units = self.inifile.find("AXIS_0", "UNITS")
except:
units = "inch"
if units == "mm" or units == "metric" or units == "1.0":
self.machine_units = _MM
else:
self.machine_units = _INCH
# if the eventbox has been clicked, we like to toggle the DRO's
# or just emit a signal to allow GUI to do what ever they want with that
# signal- gmoccapy uses this signal to open the touch off dialog
def _on_eventbox_clicked(self, widget, event):
sensible_width = self.widgets["lbl_axisletter"].get_allocation().width \
+ self.widgets["lbl_sys_main"].get_allocation().width \
+ self.widgets["hbox_up"].get_spacing() + self.margin_left
if event.x <= sensible_width:
self.emit('axis_clicked', self.widgets["lbl_axisletter"].get_text().lower())
#self.set_style("labelcolor", "#00FF00")
else:
if not self.toggle_readout_enable:
return
self.toggle_readout()
# Get propertys
def do_get_property(self, property):
name = property.name.replace('-', '_')
if name in list(self.__gproperties.keys()):
if name == 'auto_units': name = '_auto_units'
return getattr(self, name)
else:
raise AttributeError('unknown property %s' % property.name)
def convert_color(self, color):
colortuple = ((int(color.red * 255.0), int(color.green * 255.0), int(color.blue * 255.0)))
return ('#' + ''.join(f'{i:02X}' for i in colortuple))
# Set propertys
def do_set_property(self, property, value):
try:
name = property.name.replace('-', '_')
if name in list(self.__gproperties.keys()):
# setattr(self, name, value)
# self.queue_draw()
if name == 'mm_text_template':
self.mm_text_template = value
if name == 'imperial_text_template':
self.imperial_text_template = value
if name == "homed_color":
self.homed_color = self.convert_color(value)
if self.homed:
self.set_style("labelcolor", self.homed_color)
else:
self.set_style("labelcolor", self.unhomed_color)
if name == "unhomed_color":
self.unhomed_color = self.convert_color(value)
if self.homed:
self.set_style("labelcolor", self.homed_color)
else:
self.set_style("labelcolor", self.unhomed_color)
if name == "abs_color":
self.abs_color = self.convert_color(value)
self.toggle_readout(True)
if name == "rel_color":
self.rel_color = self.convert_color(value)
self.toggle_readout(True)
if name == "dtg_color":
self.dtg_color = self.convert_color(value)
self.toggle_readout(True)
if name == "auto_units":
self._auto_units = value
self._set_labels()
if name == "joint_number":
self.axis_no = self.joint = value
self.change_axisletter(_AXISLETTERS[self.axis_no])
if name == "font_size":
self.font_size = int(value)
self.set_style("size", self.font_size)
if name == "toggle_readout":
self.toggle_readout_enable = value
if name == "cycle_time":
self.cycle_time = value
if name in ('metric_units', 'actual', 'diameter'):
setattr(self, name, value)
self.queue_draw()
else:
raise AttributeError('unknown property %s' % property.name)
except:
pass
# get the actual coordinate system to display it on the DRO
def _get_current_system(self):
gcode = self.status.gcodes[1:]
for code in gcode:
if code >= 540 and code <= 590:
return "G%s" % int((code / 10))
elif code > 590 and code <= 593:
return "G%s" % (code / 10.0)
return "Rel"
# Get the units used according to gcode
def _get_current_units(self):
self.status.poll()
gcode = self.status.gcodes[1:]
for code in gcode:
if code >= 200 and code <= 210:
return (code // 10)
return False
# update the labels
def _set_labels(self):
try:
self.status.poll()
except:
pass
if self._ORDER[0] == "Rel":
self.widgets["lbl_sys_main"].set_text(self._get_current_system())
else:
self.widgets["lbl_sys_main"].set_text(self._ORDER[0])
if self._ORDER[1] == "Rel":
self.widgets["lbl_sys_left"].set_text(self._get_current_system())
else:
self.widgets["lbl_sys_left"].set_text(self._ORDER[1])
if self._ORDER[2] == "Rel":
self.widgets["lbl_sys_right"].set_text(self._get_current_system())
else:
self.widgets["lbl_sys_right"].set_text(self._ORDER[2])
self.system = self._get_current_system()
def set_style(self, property, Data):
# self.css_text = """
# .background {background-color: black;}
# .labelcolor {color: red;}
# .size_big {font-size: 25px;font-weight: bold;}
# .size_small {font-size: 10px;font-weight: bold;}
# """
if property == "background":
for widget in self.widgets:
self.widgets[widget].get_style_context().remove_class('background')
replacement_string = ".background {background-color: " + Data + ";}"
self.css_text = re.sub(r'[.][b][a][c][k][g][r][o][u][n][d].*', replacement_string, self.css_text, re.IGNORECASE)
elif property == "labelcolor":
for widget in self.widgets:
self.widgets[widget].get_style_context().remove_class('labelcolor')
replacement_string = ".labelcolor {color: " + Data + ";}"
self.css_text = re.sub(r'[.][l][a][b][e][l][c][o][l][o][r].*', replacement_string, self.css_text, re.IGNORECASE)
elif property == "size":
for widget in self.widgets:
self.widgets[widget].get_style_context().remove_class('size_big')
self.widgets[widget].get_style_context().remove_class('size_small')
replacement_string = ".size_big {font-size: " + str(Data) + "px;font-weight: bold;}"
self.css_text = re.sub(r'[.][s][i][z][e][_][b][i][g].*', replacement_string, self.css_text, re.IGNORECASE)
replacement_string = ".size_small {font-size: " + str(int(Data / 2.5)) + "px;font-weight: bold;}"
self.css_text = re.sub(r'[.][s][i][z][e][_][s][m][a][l][l].*', replacement_string, self.css_text, re.IGNORECASE)
else:
print("Got unknown property in <<set_style>>")
return
self.css.load_from_data(bytes(self.css_text, 'utf-8'))
for widget in self.widgets:
self.widgets[widget].get_style_context().add_class('background')
self.widgets[widget].get_style_context().add_class('labelcolor')
if widget in ("lbl_axisletter", "main_dro"):
self.widgets[widget].get_style_context().add_class('size_big')
else:
self.widgets[widget].get_style_context().add_class('size_small')
self.queue_draw()
def _user_system_changed(self, object, system):
self._set_labels()
def _position(self, object, p, rel_p, dtg, joint_actual_position):
# object = hal_glib Object
# p = self.stat.actual_position
# rel_p = relative position
# dtg = distance to go
# joint_actual_position = joint positions, not needed here
try:
dtg = dtg[self.axis_no]
abs_pos = p[self.axis_no]
rel_pos = rel_p[self.axis_no]
except:
return
if (self._get_current_units() == 20 and self.metric_units) or (self._get_current_units() == 21 and not self.metric_units):
if self._auto_units:
self.metric_units = not self.metric_units
self.emit("units_changed", self.metric_units)
if self.metric_units and self.machine_units == _INCH:
if self.axis_no not in (3, 4, 5):
abs_pos = abs_pos * 25.4
rel_pos = rel_pos * 25.4
dtg = dtg * 25.4
if not self.metric_units and self.machine_units == _MM:
if self.axis_no not in (3, 4, 5):
abs_pos = abs_pos / 25.4
rel_pos = rel_pos / 25.4
dtg = dtg / 25.4
if self._ORDER == ["Rel", "Abs", "DTG"]:
main, left, right = rel_pos, abs_pos, dtg
if self._ORDER == ["DTG", "Rel", "Abs"]:
main, left, right = dtg, rel_pos, abs_pos
if self._ORDER == ["Abs", "DTG", "Rel"]:
main, left, right = abs_pos, dtg, rel_pos
if self.metric_units:
tmpl = lambda s: self.mm_text_template % s
else:
tmpl = lambda s: self.imperial_text_template % s
if self.diameter:
scale = 2.0
else:
scale = 1.0
main_dro = tmpl(main * scale)
left_dro = tmpl(left * scale)
right_dro = tmpl(right * scale)
self.widgets["main_dro"].set_label(main_dro)
self.widgets["dro_left"].set_label(left_dro)
self.widgets["dro_right"].set_label(right_dro)
self.dtg = dtg * scale
self.abs_pos = abs_pos * scale
self.rel_pos = rel_pos * scale
def _not_all_homed(self, widget, data = None):
if self.status.kinematics_type == linuxcnc.KINEMATICS_IDENTITY:
self.status.poll()
self.homed = self.status.homed[self.joint_no]
else:
self.homed = False
if self.homed:
self.set_style("labelcolor", self.homed_color)
else:
self.set_style("labelcolor", self.unhomed_color)
def _all_homed(self, widget, data = None):
if self.status.kinematics_type == linuxcnc.KINEMATICS_IDENTITY:
return
if not self.homed:
self.homed = True
self.set_style("labelcolor", self.homed_color)
def _homed(self, widget, data = None):
if self.status.kinematics_type != linuxcnc.KINEMATICS_IDENTITY:
return
else:
self.status.poll()
self.homed = self.status.homed[self.joint_no]
self.set_style("labelcolor", self.homed_color)
# sets the DRO explicitly to inch or mm
# attentions auto_units also takes effect on that!
def set_to_inch(self, state):
'''
sets the DRO to show imperial units
Combi_DRO.set_to_inch(state)
state = boolean (true or False)
'''
if state:
self.metric_units = False
else:
self.metric_units = True
# If auto_units is true, the DRO will change according to the
# active gcode (G20 / G21)
def set_auto_units(self, state):
'''
if True the DRO will change units according to active gcode (G20 / G21)
Combi_DRO.set_auto_units(state)
state = boolean (true or False)
'''
self._auto_units = state
# Set the axis to diameter mode, the DRO value will be
# multiplied by 2
def set_to_diameter(self, state):
'''
if True the DRO will show the diameter not the radius, specially needed for lathes
the DRO value will be multiplied by 2
Combi_DRO.set_to_diameter(state)
state = boolean (true or False)
'''
self.diameter = state
# this will toggle the DRO around, mainly used to maintain all DRO
# at the same state, because a click on one will only change that DRO
# This can be used to change also the others
def toggle_readout(self, Data = None):
'''
toggles the order of the DRO in the widget
Combi_DRO.toggle_readout()
'''
if not Data:
self._ORDER = [self._ORDER[2], self._ORDER[0], self._ORDER[1]]
if self._ORDER[0] == "Abs":
bg_color = self.abs_color
elif self._ORDER[0] == "DTG":
bg_color = self.dtg_color
else:
bg_color = self.rel_color
self.set_style("background", bg_color)
self._set_labels()
# if Data is True, we only update the colors of the background
# so we won't emit a click event
if Data:
return
self.emit("clicked", self.joint_number, self._ORDER)
# You can change the automatic given axisletter using this function
# i.e. to use an axis as R or D insteadt of X on a lathe
def change_axisletter(self, letter):
'''
changes the automatically given axis-letter
very useful to change an lathe DRO from X to R or D
Combi_DRO.change_axis-letter(letter)
letter = string
'''
self.widgets["lbl_axisletter"].set_text(letter)
def set_joint_no(self, joint):
'''
changes the joint, not the joint number. This is handy for special
cases, like Gantry configs, i.e. XYYZ, where joint 0 = X, joint 1 = Y1
joint 2 = Y2 and joint 3 = Z, so the Z axis can be set to joint_number 2
giving the axis letter Z and joint 3 being in this case the corresponding
joint, joint 3 instead of 2
'''
self.joint_no = joint
def set_axis(self, axis):
'''
changes the axis, not the joint number. This is handy for special
cases, like Lathe configs, i.e. XZ, where joint 0 = X, joint 1 = Z
so the Z axis must be set to joint_number 1 for homing, but we need
the axis letter Z to give the correct position feedback
'''
self.axis_no = "xyzabcuvws".index(axis.lower())
# returns the order of the DRO, mainly used to maintain them consistent
# the order will also be transmitted with the clicked signal
def get_order(self):
'''
returns the order of the DRO in the widget mainly used to maintain them consistent
the order will also be transmitted with the clicked signal
Combi_DRO.get_order()
returns a list containing the order
'''
return self._ORDER
# sets the order of the DRO, mainly used to maintain them consistent
def set_order(self, order):
'''
sets the order of the DRO, mainly used to maintain them consistent
Combi_DRO.set_order(order)
order = list object, must be one of
["Rel", "Abs", "DTG"]
["DTG", "Rel", "Abs"]
["Abs", "DTG", "Rel"]
'''
self._ORDER = order
self.toggle_readout(Data=True)
# This will return the position information of all three DRO
# it will be in the order Abs, Rel, DTG
def get_position(self):
'''
returns the positions of the DRO
Combi_DRO.get_position()
returns the position of the DRO as a list of floats
the order is independent of the order shown on the DRO
and will be given as [Absolute , relative , DTG]
Absolute = the machine coordinates, depends on the actual property
will give actual or commanded position
Relative = will be the coordinates of the actual coordinate system
DTG = the distance to go, will mosltly be 0, as this function should not be used
while the machine is moving, because of time delays
'''
return self.abs_pos, self.rel_pos, self.dtg
# for testing without glade editor:
# to show some behavior and setting options
def main():
window = Gtk.Window(type = Gtk.WindowType.TOPLEVEL)
vbox = Gtk.Box(homogeneous = False, spacing = 5)
vbox.set_orientation(Gtk.Orientation.VERTICAL)
MDRO_X = Combi_DRO(0)
MDRO_Y = Combi_DRO(1)
MDRO_Z = Combi_DRO(2)
MDRO_C = Combi_DRO(5)
vbox.add(MDRO_X)
vbox.add(MDRO_Y)
vbox.add(MDRO_Z)
vbox.add(MDRO_C)
window.add(vbox)
window.connect("destroy", Gtk.main_quit)
MDRO_X.connect("clicked", clicked)
MDRO_Y.connect("clicked", clicked)
MDRO_Y.set_auto_units(False)
MDRO_Y.set_to_inch(True)
# MDRO_Y.set_to_diameter(True)
# MDRO_Y.set_property('joint_number',0)
# MDRO_Y.change_axisletter("D")
MDRO_Z.connect("clicked", clicked)
MDRO_C.connect("clicked", clicked)
MDRO_C.set_property('mm_text_template', '%10.2f')
MDRO_C.set_property('imperial_text_template', '%10.3f')
MDRO_C.set_property('toggle_readout', False)
window.show_all()
Gtk.main()
def clicked(self, axis_number, order):
'''
This signal will be emitted if the user clicked on the DRO
axis_number = the joint number of the widget
order = the actual order of the DRO in the widget
'''
print("Click received from ", axis_number)
#print("Order = ", order)
#print(self.get_position())
# self.set_property("joint_number", 0)
# other_widget.set_order(order)
# so they may be maintained consistent
if __name__ == "__main__":
main()
Reference in New Issue View Git Blame Copy Permalink