def run(self):
modbus = Modbus.Modbus('paulharrison.hopto.org')
while True:
item = []
try:
# Order: [current, power, voltage]
current_avg = modbus.read(3008,
2) # 3008 stores average current
power_avg = modbus.read(3058, 2) # 3058 stores average power
voltage_avg = modbus.read(3024,
2) # 3024 stores average voltage
total_energy = modbus.read(45098, 2)
A = modbus.read(45118, 2)
B = modbus.read(45120, 2)
C = modbus.read(45122, 2)
D = modbus.read(45124, 2)
item.append(current_avg)
item.append(power_avg)
item.append(voltage_avg)
item.append(total_energy)
item.append(A)
item.append(B)
item.append(C)
item.append(D)
time.sleep(60)
except struct.error:
print('Struct Error exception', file=sys.stderr)
time.sleep(2)
os._exit(1)
except ModbusException:
print('Modbus I/O exception', file=sys.stderr)
time.sleep(2)
os._exit(1)
self.q.put(item)
def getBinder(port, echo=None):
"""Try to open Modbus(port) and determine Binder instrument
echo - open modbus with echo True/False; if None, try both
returns Binder instance or None in case of failure"""
logger = logging.getLogger('getBinder')
if echo is None:
echos = (False, True)
else:
echos = (bool(echo), )
b = None
for echo in echos:
try:
m = Modbus(port, echo=echo)
logger.info('Using serial %s with echo %s', repr(m.ser), echo)
except (FileNotFoundError, ModbusError):
logger.exception('Opening serial port failed')
m.ser.close()
return None
for btype, bcls in BinderTypes.items():
try:
logger.debug('Trying chamber %s', btype)
b = bcls(m)
b.get_state()
except ModbusError:
logger.debug('failed')
if b is not None:
b.__del__()
b = None
else:
logger.debug('chamber is %s', btype)
return b
return None
required=True,
help='modbus port')
parser.add_argument('-u',
'--unit',
type=int,
required=True,
help='modbus unit')
parser.add_argument('-t',
'--type',
type=str,
required=True,
help='inverter type')
args = parser.parse_args()
wr = Modbus(args, logger=TableLogger())
if args.type == "tripower":
add_tripower_register(wr)
elif args.type == "sbstorage":
add_sbstorage_register(wr)
elif args.type == "sbxx-1av-41":
add_sbxx_1av_41_register(wr)
else:
sys.exit("Unknown inverter type.")
if args.list:
wr.list_available_registers()
else:
for register in args.registers:
wr.poll_register(register)
def KeyThread(modbus, scope):
'''Thread to get command from console.'''
global f
key = input("Press Enter to continue...\n> ")
f.close()
print("bye-bye")
os.kill(os.getpid(), signal.SIGINT)
if __name__ == '__main__':
global data
global f
global ReadingADC
modbus = Modbus("/dev/ttyUSB0", 115200, 5)
scope = Scope()
data = [[] for i in range(modbus.GetNumChannels())]
rt = threading.Thread(target=ReadThread, args=(modbus, scope, 0.01))
wt = threading.Thread(target=WriteThread, args=(scope, ))
kt = threading.Thread(target=KeyThread, args=(
modbus,
scope,
))
filename = "data-" + time.strftime("%Y%m%d%H%M%S") + ".txt"
f = open(filename, "w")
# Bind data to scope.
scope.data = data
# Send start sample command to oscilloscope.
modbus.StartSample()
if __name__ == '__main__':
# Pipes to Webapp
SERIAL_CHILD, SERIAL_PARENT = Pipe()
# Pipes for encoder
ENCODER_CHILD, ENCODER_PARENT = Pipe()
# Queues for sql database connector
RECORD_QUEUE = Queue()
DATA_QUEUE = Queue()
# Start AquaTROLL
TROLL = Modbus(DATA_QUEUE)
# Starts camera
CAMERA_PROCESS = Process(target=Camera.start_camera,
args=((2592, 1944), 300, "Images", RECORD_QUEUE))
CAMERA_PROCESS.start()
# Starts sql database connector that handles writing and reading(broadcasts to socket)
DATABASE_CONNECTOR = Process(target=sqlConnector.start_sqlConnector,\
args=(RECORD_QUEUE,DATA_QUEUE))
# DATABASE_CONNECTOR = Process(target=sqlConnector.start_sqlConnector,\
# args=(RECORD_QUEUE,DATA_QUEUE, ENCODER_PARENT))
DATABASE_CONNECTOR.start()
# Starts thread that runs serial communication.
parser.add_argument("serialPort", help="The serial port device to use")
parser.add_argument("--httpListenPort", help="The port for the HTTP server to listen on", type=int, default=8080)
parser.add_argument("--verbose", help="Use verbose logging", action="store_true")
args = parser.parse_args()
logging.basicConfig()
log = logging.getLogger()
if args.verbose:
log.setLevel(logging.DEBUG)
else:
log.setLevel(logging.INFO)
log.info("Listening on port {}, using device {}".format(args.httpListenPort, args.serialPort))
loop, client = AsyncModbusSerialClient(schedulers.ASYNC_IO, port=args.serialPort, baudrate=19200, method="rtu")
modbus = Modbus(client.protocol)
handler = HttpHandler(modbus)
app = web.Application()
app.add_routes([
web.get("/", handler.handle_root),
web.get("/summary", handler.get_summary),
web.get("/mode/{flag}", handler.get_mode_status),
web.post("/mode/{flag}", handler.set_mode_status),
web.post("/setSetting/{setting}/{value}", handler.set_setting)
])
try:
loop.run_until_complete(web._run_app(app, port=args.httpListenPort))
finally:
loop.close()
class RootWidget(FloatLayout):
buttons_is_disable = False
sync_param_process = False
com_num = 1
motor = Modbus()
speed = -1
accel_time = -1
deccel_time = -1
auto_speed = -1
auto_accel_time = -1
auto_deccel_time = -1
manual_speed = -1
manual_accel_time = -1
manual_deccel_time = -1
work_time = -1
reverse = False
auto_presets = []
manual_presets = []
selected_preset = -1
com_input = ObjectProperty()
connect_button = ObjectProperty()
speed_input = ObjectProperty()
speed_error_img = ObjectProperty()
accel_time_input = ObjectProperty()
accel_error_img = ObjectProperty()
deccel_time_input = ObjectProperty()
deccel_error_img = ObjectProperty()
work_time_input = ObjectProperty()
work_error_img = ObjectProperty()
motor_switch = ObjectProperty()
apply_param_button = ObjectProperty()
preset_button = ObjectProperty()
add_preset_button = ObjectProperty()
del_preset_button = ObjectProperty()
sync_params_button = ObjectProperty()
def error(self, text):
ErrorPopup(text)
def resource_path(self, relative_path):
print(resource_path(relative_path))
return resource_path(relative_path)
def save_params(self):
with open(appdata_path + 'settings.txt', 'w') as f:
f.write(str(self.com_num) + '\n')
f.write(str(self.auto_speed) + '\n')
f.write(str(self.auto_accel_time) + '\n')
f.write(str(self.auto_deccel_time) + '\n')
f.write(str(self.work_time) + '\n')
f.write(str(self.reverse) + '\n')
f.write(str(self.manual_speed) + '\n')
f.write(str(self.manual_accel_time) + '\n')
f.write(str(self.manual_deccel_time) + '\n')
def load_params(self):
try:
f = open(appdata_path + 'settings.txt')
self.com_num = int(f.readline())
auto_speed = f.readline().strip()
if auto_speed != '-1':
self.speed_input.text = auto_speed
self.accel_time_input.text = f.readline().strip()
self.deccel_time_input.text = f.readline().strip()
self.work_time_input.text = f.readline().strip()
self.work_time = int(self.work_time_input.text)
self.reverse = f.readline().strip() == 'True'
else:
for i in range(4):
f.readline()
manual_speed = int(f.readline())
if manual_speed != -1:
self.manual_speed = manual_speed
self.manual_accel_time = int(f.readline())
self.manual_deccel_time = int(f.readline())
f.close()
except:
print('load params error')
def save_presets(self):
with open(appdata_path + 'presets.prs', 'wb') as f:
presets = [self.auto_presets, self.manual_presets]
pickle.dump(presets, f)
def load_presets(self):
try:
with open(appdata_path + 'presets.prs', 'rb') as f:
presets = pickle.load(f)
self.auto_presets = presets[0]
self.manual_presets = presets[1]
except:
self.auto_presets = []
self.manual_presets = []
def check_param_equals(self):
if int(self.speed_input.text) != self.speed:
self.speed_error_img.color = (1, 1, 1, 1)
else:
self.speed_error_img.color = (1, 1, 1, 0)
if int(self.accel_time_input.text) != self.accel_time:
self.accel_error_img.color = (1, 1, 1, 1)
else:
self.accel_error_img.color = (1, 1, 1, 0)
if int(self.deccel_time_input.text) != self.deccel_time:
self.deccel_error_img.color = (1, 1, 1, 1)
else:
self.deccel_error_img.color = (1, 1, 1, 0)
if int(self.work_time_input.text) != self.work_time:
self.work_error_img.color = (1, 1, 1, 1)
else:
self.work_error_img.color = (1, 1, 1, 0)
def set_param(self, register, value):
if myApp.auto_mode:
if register == ServoReg.SPEED:
self.auto_speed = self.speed = value
self.speed_input.text = str(value)
elif register == ServoReg.ACCEL_TIME:
self.auto_accel_time = self.accel_time = value
self.accel_time_input.text = str(value)
elif register == ServoReg.DECCEL_TIME:
self.auto_deccel_time = self.deccel_time = value
self.deccel_time_input.text = str(value)
else:
if register == ServoReg.SPEED:
self.manual_speed = self.speed = value
self.speed_input.text = str(value)
elif register == ServoReg.ACCEL_TIME:
self.manual_accel_time = self.accel_time = value
self.accel_time_input.text = str(value)
elif register == ServoReg.DECCEL_TIME:
self.manual_deccel_time = self.deccel_time = value
self.deccel_time_input.text = str(value)
if register == ServoReg.DECCEL_TIME and self.sync_param_process:
self.sync_param_process = False
if self.motor_switch.active:
self.disable_buttons(False)
self.check_param_equals()
self.save_params()
def servo_sync_params(self, instance):
self.sync_param_process = True
self.disable_buttons(True)
registers = [ServoReg.SPEED, ServoReg.ACCEL_TIME, ServoReg.DECCEL_TIME]
for register in registers:
def check_answer(*args, **kwargs):
try:
ans = kwargs['ans']
register = kwargs['register']
if ans[:7] == ':010302':
myApp.root_widget.set_param(register,
int(ans[7:11], 16))
except:
pass
self.motor.get_param(register, check_answer)
def add_preset_popup(self, instance):
popup = AddPresetPopup()
popup.open()
def add_preset(self, name):
preset = Preset(name, int(self.speed_input.text),
int(self.accel_time_input.text),
int(self.deccel_time_input.text),
int(self.work_time_input.text))
if myApp.auto_mode:
self.auto_presets.append(preset)
else:
self.manual_presets.append(preset)
self.save_presets()
self.update_presets_dropdown()
def del_preset(self):
if self.selected_preset >= 0:
if myApp.auto_mode:
del self.auto_presets[self.selected_preset]
else:
del self.manual_presets[self.selected_preset]
self.save_presets()
self.update_presets_dropdown()
self.preset_button.text = 'Пресет'
def del_preset_btn(self, instance):
if self.selected_preset >= 0:
quest_popup = QuestionPopup()
quest_popup.ok_func = self.del_preset
quest_popup.question.text = 'Вы действительно хотите удалить пресет?'
quest_popup.open()
def select_preset(self, instance):
self.selected_preset = int(instance.id)
if myApp.auto_mode:
preset = self.auto_presets[self.selected_preset]
else:
preset = self.manual_presets[self.selected_preset]
self.preset_button.text = instance.text
self.speed_input.text = str(preset.speed)
self.accel_time_input.text = str(preset.accel_time)
self.deccel_time_input.text = str(preset.deccel_time)
self.work_time_input.text = str(preset.work_time)
self.dropdown.dismiss()
self.check_param_equals()
def com_changed(self, instance, value):
try:
if len(instance.text) > 2:
instance.text = value[:-1]
self.com_num = int(value)
self.save_params()
except:
instance.text = value[:-1]
def change_connect(self, instance):
if not self.motor.is_connect:
self.connect()
else:
self.disconnect()
def connect(self):
self.motor.connect(self.com_num, myApp)
if not self.motor.is_connect:
pass
else:
self.connect_button.text = 'Отключиться'
self.motor_switch.disabled = False
self.apply_param_button.disabled = False
self.sync_params_button.disabled = False
self.servo_sync_params(None)
def disconnect(self):
self.motor.disconnect()
if not self.motor.is_connect:
self.connect_button.text = 'Соединиться'
self.motor_switch.active = False
self.motor_switch.disabled = True
self.apply_param_button.disabled = True
self.sync_params_button.disabled = True
self.disable_buttons(True)
def disable_buttons(self, val):
self.buttons_is_disable = val
myApp.mode_widget.disable_buttons(val)
def motor_change_state(self, instance, value):
if value:
def check_motor_is_on(*args, **kwargs):
ans = kwargs['ans']
right_ans = kwargs['right_ans']
if ans == right_ans:
myApp.root_widget.disable_buttons(not value)
self.motor.servo_on(func=check_motor_is_on)
else:
self.motor.servo_off()
self.disable_buttons(not value)
def servo_set_params(self, instance):
def apply_param(*args, **kwargs):
ans = kwargs['ans']
right_ans = kwargs['right_ans']
if ans == right_ans:
register = int(ans[5:9], 16)
value = int(ans[9:13], 16)
myApp.root_widget.set_param(register, value)
speed = int(self.speed_input.text)
accel_time = int(self.accel_time_input.text)
deccel_time = int(self.deccel_time_input.text)
values = [speed, accel_time, deccel_time]
registers = [ServoReg.SPEED, ServoReg.ACCEL_TIME, ServoReg.DECCEL_TIME]
self.sync_param_process = True
self.disable_buttons(True)
for i, val in enumerate(values):
try:
if val < 0:
val = 0
if i == 0 and val == 0:
val = 100
self.motor.set_param(register=registers[i],
value=val,
func=apply_param)
except:
pass
try:
self.work_time = int(self.work_time_input.text)
except:
pass
self.save_params()
def update_presets_dropdown(self):
self.preset_button.text = 'Пресет'
self.selected_preset = -1
self.dropdown.clear_widgets()
if myApp.auto_mode:
presets = self.auto_presets
else:
presets = self.manual_presets
for index, preset in enumerate(presets):
btn = Button(id=str(index),
text=str(preset.name),
size_hint_y=None,
height=25)
btn.bind(on_release=self.select_preset)
self.dropdown.add_widget(btn)
def __init__(self, **kwargs):
super().__init__(**kwargs)
try:
self.load_params()
except:
pass
self.load_presets()
self.com_input.text = str(self.com_num)
print('com bind')
self.com_input.bind(text=self.com_changed)
self.connect_button.bind(on_press=self.change_connect)
self.motor_switch.bind(active=self.motor_change_state)
self.motor_switch.disabled = True
self.dropdown = DropDown()
self.update_presets_dropdown()
self.preset_button.bind(on_release=self.dropdown.open)
print('buttons bind')
self.add_preset_button.bind(on_press=self.add_preset_popup)
self.del_preset_button.bind(on_press=self.del_preset_btn)
self.apply_param_button.bind(on_press=self.servo_set_params)
self.apply_param_button.disabled = True
self.sync_params_button.bind(on_press=self.servo_sync_params)
self.sync_params_button.disabled = True
print('root_widget builded.')
class ServolineMotorApp(MainForm):
reverse = False
mode = 'auto'
motor = Modbus()
auto_speed = 50
auto_accel_time = 200
auto_deccel_time = 200
auto_work_time = 0
manual_speed = 50
manual_accel_time = 200
manual_deccel_time = 200
auto_groups = []
auto_groups_id = -1
auto_presets = []
manual_presets = []
auto_presets_id = -1
manual_presets_id = -1
sync_param_process = False
settings_file = DictionaryParser(appdata_path + 'settings.txt')
def save_params(self):
params = {'com': self.com.get()}
auto = {
'speed': self.auto_speed,
'accel_time': self.auto_accel_time,
'deccel_time': self.auto_deccel_time,
'work_time': self.auto_work_time,
'preset_id': self.auto_presets_id,
'group_id': self.auto_groups_id,
'reverse': self.reverse
}
manual = {
'speed': self.manual_speed,
'accel_time': self.manual_accel_time,
'deccel_time': self.manual_deccel_time,
'preset_id': self.manual_presets_id
}
params['auto'] = auto
params['manual'] = manual
try:
self.settings_file.save_dict(params)
except:
print('save params error')
def load_params(self):
try:
params = self.settings_file.load_dict()
self.com.set(params['com'])
auto = params['auto']
self.auto_speed = auto['speed']
self.auto_accel_time = auto['accel_time']
self.auto_deccel_time = auto['deccel_time']
self.auto_presets_id = auto['preset_id']
self.auto_groups_id = auto.get('group_id', -1)
self.reverse = auto['reverse']
manual = params['manual']
self.manual_speed = manual['speed']
self.manual_accel_time = manual['accel_time']
self.manual_deccel_time = manual['deccel_time']
self.manual_presets_id = manual['preset_id']
self.speed.set(self.auto_speed)
self.accel_time.set(self.auto_accel_time)
self.deccel_time.set(self.auto_deccel_time)
self.work_time.set(self.auto_work_time)
except:
print('load params error')
def save_presets(self):
id = self.combobox_presets.current()
if self.mode == 'auto':
self.auto_presets_id = id
else:
self.manual_presets_id = id
self.save_params()
with open(appdata_path + 'presets.prs', 'wb') as f:
presets = [self.auto_presets, self.manual_presets]
pickle.dump(presets, f)
with open(appdata_path + 'groups.prs', 'wb') as f:
pickle.dump(self.auto_groups, f)
def load_presets(self):
try:
with open(appdata_path + 'presets.prs', 'rb') as f:
presets = pickle.load(f)
self.auto_presets = presets[0]
self.manual_presets = presets[1]
except:
self.auto_presets = []
self.manual_presets = []
try:
with open(appdata_path + 'groups.prs', 'rb') as f:
self.auto_groups = pickle.load(f)
except:
self.auto_groups = []
self.auto_groups_id = -1
def check_param_equals(self):
pass
def enable_buttons(self, val):
self.auto.enable_buttons(val)
self.manual.enable_buttons(val)
def change_connect(self):
if not self.motor.is_connect:
self.connect()
else:
self.disconnect()
def connect(self):
self.motor.connect(self.com.get(), self)
if self.motor.is_connect:
self.btn_connect['text'] = 'Отключиться'
self.switch_motor['state'] = 'normal'
self.servo_sync_params()
self.preset_var.set('Выбрать пресет')
def disconnect(self):
self.motor.disconnect()
if not self.motor.is_connect:
self.btn_connect['text'] = 'Подключиться'
self.switch_motor.set_val(False)
self.switch_motor['state'] = 'disabled'
self.enable_buttons(True)
def motor_change_state(self, value):
if value:
def check_motor_is_on(*args, **kwargs):
ans = kwargs['ans']
right_ans = kwargs['right_ans']
if ans == right_ans:
self.enable_buttons(value)
self.motor.servo_on(right_func=check_motor_is_on)
else:
self.motor.servo_off()
self.enable_buttons(value)
def set_param_in_entry(self, register, value):
if self.mode == 'auto':
if register == ServoReg.SPEED:
self.auto_speed = value
self.speed.set(value)
elif register == ServoReg.ACCEL_TIME:
self.auto_accel_time = value
self.accel_time.set(value)
elif register == ServoReg.DECCEL_TIME:
self.auto_deccel_time = value
self.deccel_time.set(value)
else:
if register == ServoReg.SPEED:
self.manual_speed = value
self.speed.set(value)
elif register == ServoReg.ACCEL_TIME:
self.manual_accel_time = value
self.accel_time.set(value)
elif register == ServoReg.DECCEL_TIME:
self.manual_deccel_time = value
self.deccel_time.set(value)
if register == ServoReg.DECCEL_TIME and self.sync_param_process:
self.sync_param_process = False
if self.switch_motor.val:
self.enable_buttons(True)
self.check_param_equals()
self.save_params()
def servo_sync_params(self):
self.sync_param_process = True
registers = [ServoReg.SPEED, ServoReg.ACCEL_TIME, ServoReg.DECCEL_TIME]
for register in registers:
def check_answer(*args, **kwargs):
try:
ans = kwargs['ans']
register = kwargs['register']
if ans[:7] == ':010302':
self.set_param_in_entry(register, int(ans[7:11], 16))
except:
pass
self.motor.get_param(register=register, right_func=check_answer)
def servo_set_params(self):
if self.motor.is_connect:
def apply_param(*args, **kwargs):
ans = kwargs['ans']
right_ans = kwargs['right_ans']
if ans == right_ans:
register = int(ans[5:9], 16)
value = int(ans[9:13], 16)
self.set_param_in_entry(register, value)
else:
self.error('param apply on motor error')
speed = self.speed.get()
accel_time = self.accel_time.get()
deccel_time = self.deccel_time.get()
values = [speed, accel_time, deccel_time]
registers = [
ServoReg.SPEED, ServoReg.ACCEL_TIME, ServoReg.DECCEL_TIME
]
self.sync_param_process = True
for i, val in enumerate(values):
def set_param_on_motor(*args, **kwargs):
try:
ans = kwargs['ans']
current_val = kwargs['current_val']
register = kwargs['register']
# set_param if difference
if (ans[:7] == ':010302' and int(ans[7:11], 16) !=
current_val) or (ans[:7] != ':010302'):
try:
if current_val < 0:
current_val = 0
if i == 0 and current_val == 0:
current_val = 100
self.motor.set_param(register=register,
value=current_val,
right_func=apply_param)
except:
self.error('error set param on motor in if')
except:
self.error('error set param on motor')
self.motor.get_param(register=registers[i],
right_func=set_param_on_motor,
current_val=val)
try:
self.auto_work_time = int(self.work_time.get())
except:
pass
self.save_params()
self.enable_buttons(self.switch_motor.val)
def param_changed(self):
values = ['speed', 'accel_time', 'deccel_time']
for val in values:
if eval('self.' + str(self.mode) + '_' + str(val) +'!=self.' + str(val) + '.get()')or\
(self.auto_work_time!=self.work_time.get()):
self.image_speed_error.place(x=230, y=50)
def param_change_complete(self):
values = ['speed', 'accel_time', 'deccel_time']
for val in values:
if eval('self.' + str(self.mode) + '_' + str(val) +'!=self.' + str(val) + '.get()')or\
(self.auto_work_time!=self.work_time.get()):
self.save_params()
self.servo_set_params()
if self.mode == 'auto':
self.auto_presets_id = -1
else:
self.manual_presets_id = -1
break
if (self.mode == 'auto' and self.auto_presets_id == -1)or\
(self.mode == 'manual' and self.manual_presets_id == -1):
self.preset_var.set('Выбрать пресет')
self.image_speed_error.place_forget()
def change_mode(self):
self.enable_buttons(False)
if self.mode == 'auto':
self.mode = 'manual'
self.auto.hide()
self.manual.show()
self.auto_speed = self.speed.get()
self.auto_accel_time = self.accel_time.get()
self.auto_deccel_time = self.deccel_time.get()
self.auto_work_time = self.work_time.get()
self.speed.set(self.manual_speed)
self.accel_time.set(self.manual_accel_time)
self.deccel_time.set(self.manual_deccel_time)
self.work_time.set(0)
self.hide_groups_menu()
id_pres = self.manual_presets_id
self.update_presets_combobox()
else:
self.mode = 'auto'
self.manual.hide()
self.auto.show()
self.manual_speed = self.speed.get()
self.manual_accel_time = self.accel_time.get()
self.manual_deccel_time = self.deccel_time.get()
self.speed.set(self.auto_speed)
self.accel_time.set(self.auto_accel_time)
self.deccel_time.set(self.auto_deccel_time)
self.work_time.set(self.auto_work_time)
self.show_groups_menu()
id_pres = self.auto_presets_id
if self.auto_presets_id > -1:
self.group_selected(None, pr_sel_index=self.auto_presets_id)
else:
self.update_presets_combobox()
self.servo_set_params()
if id_pres > -1:
self.combobox_presets.current(id_pres)
else:
self.preset_var.set('Выбрать пресет')
def show_group_window(self, new=False):
self.group_master = Toplevel(self.master)
if new:
self.group_window = GroupSettingsWindow(self, self.group_master)
else:
self.group_window = GroupSettingsWindow(self, self.group_master,
self.auto_groups_id)
def show_add_preset_window(self):
self.add_preset_master = Toplevel(self.master)
self.add_preset_window = AddPresetWindow(self, self.add_preset_master)
def show_preset_settings_window(self):
self.pr_st_master = Toplevel(self.master)
self.pr_st_window = PresetSettingsWindow(self, self.pr_st_master,
self.get_cur_preset())
def get_cur_preset(self):
index = self.combobox_presets.current()
if self.mode == 'auto':
if self.auto_groups_id == -1:
return self.auto_presets[index]
else:
return self.auto_groups[self.auto_groups_id].presets[index]
else:
return self.manual_presets[index]
def get_cur_group(self):
return self.auto_groups[self.auto_groups_id]
def add_preset(self, name):
preset = Preset(name, self.speed.get(), self.accel_time.get(),
self.deccel_time.get())
if self.mode == 'auto':
preset.work_time = self.work_time.get()
if self.auto_groups_id == -1:
self.auto_presets.append(preset)
else:
self.auto_groups[self.auto_groups_id].presets.append(preset)
self.group_selected(None,
len(self.get_cur_group().presets) - 1)
self.save_presets()
return
else:
self.manual_presets.append(preset)
self.save_presets()
self.update_presets_combobox()
index = len(self.combobox_presets['values']) - 1
self.combobox_presets.current(index)
def change_preset(self):
index = self.combobox_presets.current()
if self.mode == 'auto':
preset = self.auto_presets[index]
preset.work_time = self.work_time.get()
else:
preset = self.manual_presets[index]
preset.speed = self.speed.get()
preset.accel_time = self.accel_time.get()
preset.deccel_time = self.deccel_time.get()
self.save_presets()
def save_preset(self, preset):
cur_preset = self.get_cur_preset()
for attr in cur_preset.__dict__.keys():
cur_preset.__dict__[attr] = preset.__dict__[attr]
self.save_presets()
self.group_selected(None, self.auto_presets_id)
def del_preset(self):
index = self.combobox_presets.current()
if self.mode == 'auto':
if self.auto_groups_id == -1:
del self.auto_presets[index]
else:
del self.auto_groups[self.auto_groups_id].presets[index]
self.group_selected(None)
else:
del self.manual_presets[index]
self.update_presets_combobox()
self.preset_var.set('Выбрать пресет')
self.save_presets()
def up_group(self):
id = self.combobox_preset_groups.current()
if id > 0 and id < len(self.auto_groups):
group = self.auto_groups[id]
self.auto_groups[id] = self.auto_groups[id - 1]
self.auto_groups[id - 1] = group
self.update_groups_combobox()
self.combobox_preset_groups.current(id - 1)
self.auto_groups_id = self.combobox_preset_groups.current()
self.save_presets()
def down_group(self):
id = self.combobox_preset_groups.current()
if id > -1 and id < len(self.auto_groups) - 1:
group = self.auto_groups[id]
self.auto_groups[id] = self.auto_groups[id + 1]
self.auto_groups[id + 1] = group
self.update_groups_combobox()
self.combobox_preset_groups.current(id + 1)
self.auto_groups_id = self.combobox_preset_groups.current()
self.save_presets()
def up_preset(self):
if self.mode == 'manual' or self.auto_groups_id == -1:
preset_list = eval('self.' + self.mode + '_presets')
else:
preset_list = self.get_cur_group().presets
id = self.combobox_presets.current()
if id > 0 and id < len(preset_list):
preset = preset_list[id]
preset_list[id] = preset_list[id - 1]
preset_list[id - 1] = preset
self.update_presets_combobox()
self.combobox_presets.current(id - 1)
self.auto_presets_id = self.combobox_presets.current()
self.save_presets()
def down_preset(self):
if self.mode == 'manual' or self.auto_groups_id == -1:
preset_list = eval('self.' + self.mode + '_presets')
else:
preset_list = self.get_cur_group().presets
id = self.combobox_presets.current()
if id > -1 and id < len(preset_list) - 1:
preset = preset_list[id]
preset_list[id] = preset_list[id + 1]
preset_list[id + 1] = preset
self.update_presets_combobox()
self.combobox_presets.current(id + 1)
self.auto_presets_id = self.combobox_presets.current()
self.save_presets()
def group_selected(self, event, pr_sel_index=0):
index = self.combobox_preset_groups.current()
self.auto_groups_id = index
if self.mode == 'auto':
group = self.auto_groups[index]
self.update_presets_combobox()
if len(group.presets) > 0:
self.combobox_presets.current(pr_sel_index)
self.preset_selected(None)
else:
self.preset_var.set('Нет пресетов')
def save_group(self, name, presets_ids, group_id=-1):
presets = [self.auto_presets[pr_id] for pr_id in presets_ids]
if group_id < 0:
group = Group(name, presets)
self.auto_groups.append(group)
else:
self.auto_groups[group_id].name = name
self.auto_groups[group_id].presets = presets
self.save_presets()
self.update_groups_combobox()
if group_id < 0:
self.combobox_preset_groups.current(len(self.auto_groups) - 1)
else:
self.combobox_preset_groups.current(group_id)
self.group_selected(None)
def delete_group(self, id):
self.auto_groups.pop(id)
self.auto_groups_id = -1
self.save_params()
self.save_presets()
self.update_groups_combobox()
self.update_presets_combobox()
def preset_selected(self, event):
preset = self.get_cur_preset()
if self.mode == 'auto':
self.auto_speed = preset.speed
self.auto_accel_time = preset.accel_time
self.auto_deccel_time = preset.deccel_time
self.auto_work_time = preset.work_time
self.auto_presets_id = self.combobox_presets.current()
else:
self.manual_speed = preset.speed
self.manual_accel_time = preset.accel_time
self.manual_deccel_time = preset.deccel_time
self.manual_presets_id = self.combobox_presets.current()
self.speed.set(preset.speed)
self.accel_time.set(preset.accel_time)
self.deccel_time.set(preset.deccel_time)
if hasattr(preset, 'work_time'):
self.work_time.set(preset.work_time)
else:
self.work_time.set(0)
self.servo_set_params()
self.save_params()
def update_groups_combobox(self):
group_names = []
for group in self.auto_groups:
group_names.append(group.name)
self.combobox_preset_groups['values'] = group_names
if len(group_names) == 0:
self.preset_groups_var.set('Все пресеты')
def update_presets_combobox(self):
preset_names = []
if self.mode == 'auto':
if self.auto_groups_id > -1:
group = self.auto_groups[self.auto_groups_id]
preset_list = group.presets
else:
preset_list = self.auto_presets
else:
preset_list = self.manual_presets
for preset in preset_list:
preset_names.append(preset.name)
self.combobox_presets['values'] = preset_names
def show_notify_window(self, title, text):
self.notify_master = Toplevel(self.master)
self.notify_window = NotifyWindow(self, self.notify_master, title,
text)
def error(self, text):
self.show_notify_window('Ошибка', text)
def set_default_settings(self):
self.preset_var.set('Выбрать пресет')
self.preset_groups_var.set('Все пресеты')
self.width = 400
self.height = 360
self.master.geometry('%dx%d' % (self.width, self.height))
self.master.title("Servoline Motor")
self.master.iconbitmap("icon.ico")
self.master.resizable(False, False)
def show_groups_menu(self):
self.show_element(self.combobox_preset_groups)
self.show_element(self.btn_group_settings)
self.show_element(self.btn_group_add)
self.show_element(self.btn_up_group)
self.show_element(self.btn_down_group)
def hide_groups_menu(self):
self.hide_element(self.combobox_preset_groups)
self.hide_element(self.btn_group_settings)
self.hide_element(self.btn_group_add)
self.hide_element(self.btn_up_group)
self.hide_element(self.btn_down_group)
def __init__(self, master):
self.master = master
super().__init__(self.master)
self.set_default_settings()
self.load_params()
self.load_presets()
self.update_groups_combobox()
if self.auto_groups_id > -1:
self.combobox_preset_groups.current(self.auto_groups_id)
self.update_presets_combobox()
if self.auto_presets_id > -1:
self.combobox_presets.current(self.auto_presets_id)
preset = self.auto_presets[self.auto_presets_id]
self.speed.set(preset.speed)
self.accel_time.set(preset.accel_time)
self.deccel_time.set(preset.deccel_time)
self.work_time.set(preset.work_time)
self.auto = AutoMode(self)
self.manual = ManualMode(self)
self.auto.show()
self.btn_connect.bind_release(self.change_connect)
self.switch_motor.bind_sw(self.motor_change_state)
self.switch_motor.val = True
self.switch_motor.change_val()
self.btn_group_settings.bind_release(self.show_group_window)
self.btn_group_add.bind_release(
lambda: self.show_group_window(new=True))
self.btn_up_group.bind_release(self.up_group)
self.btn_down_group.bind_release(self.down_group)
self.btn_preset_settings.bind_release(self.show_preset_settings_window)
self.btn_add_preset.bind_release(self.show_add_preset_window)
self.btn_up_preset.bind_release(self.up_preset)
self.btn_down_preset.bind_release(self.down_preset)
