class Triangulation:
"""
A service for determining the relative location of a device with respect to
nearby Wifi access points.
"""
def __init__(self, wifi: Wifi, mqtt: MqttConnection,
messaging: MessagingService, oled):
self.table = RssiTable()
self.wifi = wifi
self.mqtt = mqtt
self.messaging = messaging
self.thread = Thread(self.__run, "LocationThread")
self.oled = oled
self.previous_snapshot = []
def start(self):
self.thread.start()
def __unique_sets(self, a, b):
for (a_elem, _, _) in a:
for (b_elem, _, _) in b:
if a_elem == b_elem:
return False
return True
def __run(self, thread: Thread):
while thread.active:
if self.messaging.package_id:
# We cannot scan if we are connected to an access point
self.wifi.disconnect()
self.wifi.acquire()
try:
stations = self.wifi.scan()
print("Got {}".format(stations))
finally:
self.wifi.release()
self.wifi.deactivate(False)
for station in stations:
# Filter out mobile network used while testing
if station[0] != b"AndroidAP":
self.table.add(ubinascii.hexlify(station[1]),
station[3])
self.table.clean_table()
new_snapshot = self.table.snapshot(2)
if len(stations) >= 2 and self.__unique_sets(
new_snapshot, self.previous_snapshot):
self.previous_snapshot = new_snapshot
payload = ujson.dumps(self.previous_snapshot)
self.mqtt.publish(
TOPIC_MACLOCATION_PUBLISH.format(
self.messaging.package_id), payload)
self.messaging.notify()
self.oled.push_line("Got location")
utime.sleep(27)
def now(bot, update, args):
if str(update.message.chat_id) in allowed_id:
try:
usernames = [ a['username'].lower() for a in users ]
if not args[1].lower() in usernames:
update.message.reply_text("Sorry, username <b>{}</b> is not saved.".format(args[1]), parse_mode='HTML')
return
if not args[0] in scripts:
update.message.reply_text("Sorry, script named <b>{}</b> is not in your scripts file.".format(args[0]), parse_mode='HTML')
return
job_name = "{}_temp_{}".format(args[0], time.time())
for user in users:
if user['username'].lower() == args[1].lower():
break
temp_thread = Thread(
job_name,
args[0],
update.message.chat_id,
bot,
user['username'],
user['password'],
user['proxy']
)
temp_thread.start()
except (IndexError, ValueError):
update.message.reply_text('Usage: /now <script_name> <username>')
else:
message = 'You have not the permission to use this bot.\nFor more details visit [Telegram-InstaPy-Scheduling](https://github.com/Tkd-Alex/Telegram-InstaPy-Scheduling)'
update.message.reply_text(message, parse_mode='Markdown')
async def on_ready():
print(f"Ready in {time.time() - start} seconds.")
# used for uptime
client.start_time = datetime.now()
await client.change_presence(status=discord.Status.online, activity=discord.Game(auth.game))
print('Successfully logged in.')
Thread.start(block=False)
def __init__(self, com):
#self.repl = pyb.USB_VCP()
self.uart = pyb.UART(com, 9600,bits=8, parity=None, stop=1,read_buf_len=15024,timeout=10) # ,bits=8, parity=None, stop=1,read_buf_len=64
#self.pin = pyb.Pin('X18', pyb.Pin.OUT_PP, pyb.Pin.PULL_NONE)
#self.pin.low()
self.data=None
self.read_n='DATA'
self.msgss=None
#self.word=''
tr1 = Thread(target=self.download)#, args=(self.data)
tr1.start()
class ThreadingTutorial(QMainWindow, ui.Ui_MainWindow):
def __init__(self):
super(self.__class__, self).__init__()
self.setupUi(self)
# self._diawidth = 1500
# self._diaheight = 800
#
def show_text(self):
self.textEdit.setText("我是自定义线程")
imagefilename = QFileDialog.getOpenFileName(self, "OpenFile",
"/Users/huan/code/PycharmProjects/Unsupervised-Person-Re-identification-Clustering-and-Fine-tuning-master/mydata/imageQuery",
"Image Files(*.MTS *.jpg *.png)")
print("imagefilename1")
print(imagefilename)
imagefilename1 = "".join(tuple(imagefilename))
imagefilename = imagefilename1[0:-30]
print("imagefilename")
print(imagefilename)
image = QImage()
if imagefilename != "":
image = QImage(imagefilename)
scene = QGraphicsScene()
pixmap = QPixmap.fromImage(image)
#默认加载比例
scene.addPixmap(pixmap).setScale(0.5)
self.graphicsView.setScene(scene)
self.graphicsView.resize(150, 200)
self.graphicsView.show()
def done(self):
self.textEdit.setText("内置线程：我是系统线程完成后的done函数")
def test(self):
self.textEdit.setText("我是按钮点击事件，设置文本值")
self.thread = Thread()
self.thread.start()
#使用自定义信号
self.thread.show_text.connect(self.show_text)
#使用系统信号
self.thread.finished.connect(self.done)
def on_pushButton_released(self):
self.test()
def MainLoop(gui, sim):
# Create a simulation thread, and start it at the highest priority
simthread = Thread(sim)
simthread.start(Thread.HighestPriority)
# Set sim.screenio as an event target for the gui, so that the gui can send events to the sim object
gui.setSimEventTarget(sim.screenio)
# Start the gui
gui.start()
# Stopping simulation thread
print 'Stopping Threads'
sim.stop()
simthread.quit()
simthread.wait()
class PackageMonitor:
def __init__(self, mqtt: MqttConnection, messaging: MessagingService,
budget_manager: BudgetManager):
self.mqtt = mqtt
self.messaging = messaging
self.budget_manager = budget_manager
self.environment_thread = Thread(self.__run_environment,
"EnvironmentThread")
self.motion_thread = Thread(self.__run_motion, "MotionThread")
self.temperature_setpoint = config.get_float("temperature_setpoint")
self.humidity_setpoint = config.get_float("humidity_setpoint")
self.motion_setpoint = config.get_float("motion_setpoint")
self.last_z = 0
self.last_y = 0
self.last_x = 0
self.environment_sensor = HTS221(
I2C(-1, Pin(26, Pin.IN), Pin(25, Pin.OUT)))
self.motion_sensor = MPU6050(I2C(-1, Pin(26, Pin.IN), Pin(25,
Pin.OUT)))
def __subscribe_package_id(self):
self.mqtt.subscribe(TOPIC_DEVICE_PACKAGE.format(self.mqtt.device_id),
self._on_package_id, 1)
self.messaging.notify()
def _on_package_id(self, topic, package_id):
# We should unsubscribe from the old id, but umqttsimple does not support this!
self.mqtt.subscribe(TOPIC_TEMPERATURE_SETPOINT.format(package_id),
self._on_temperature_setpoint, 1)
self.mqtt.subscribe(TOPIC_HUMIDITY_SETPOINT.format(package_id),
self._on_humidity_setpoint, 1)
self.mqtt.subscribe(TOPIC_MOTION_SETPOINT.format(package_id),
self._on_motion_setpoint, 1)
self.messaging.notify()
def start(self):
self.__subscribe_package_id()
self.environment_thread.start()
self.motion_thread.start()
def __run_environment(self, thread: Thread):
while thread.active:
did_transmit = False
if self.temperature_setpoint:
if self.__check_temperature():
did_transmit = True
if self.humidity_setpoint:
if self.__check_humidity():
did_transmit = True
if did_transmit:
print("Notified messaging service of pending data")
self.messaging.notify()
utime.sleep(10)
def __run_motion(self, thread: Thread):
while thread.active:
did_transmit = False
if self.motion_setpoint:
if self.__check_motion():
did_transmit = True
if did_transmit:
print("Notified messaging service of pending data")
self.messaging.notify()
utime.sleep_ms(100)
def __check_temperature(self) -> bool:
temperature = self.environment_sensor.read_temp()
print("Read temperature: {}".format(temperature))
if temperature > self.temperature_setpoint:
time = utime.localtime()
self.budget_manager.enqueue(
TOPIC_TEMPERATURE_PUBLISH.format(self.messaging.package_id),
time, temperature, self.temperature_setpoint)
return True
return False
def __check_humidity(self) -> bool:
humidity = self.environment_sensor.read_humi()
print("Read humidity: {}".format(humidity))
if humidity > self.humidity_setpoint:
time = utime.localtime()
self.budget_manager.enqueue(
TOPIC_HUMIDITY_PUBLISH.format(self.messaging.package_id), time,
humidity, self.humidity_setpoint)
return True
return False
def __check_motion(self) -> bool:
values = self.motion_sensor.get_values()
z = values['AcZ']
y = values['AcY']
x = values['AcX']
motion = math.fabs(z + y + x - self.last_z - self.last_y - self.last_x)
self.last_z = z
self.last_y = y
self.last_x = x
if motion > self.motion_setpoint: #20000
time = utime.time()
self.budget_manager.enqueue(
TOPIC_MOTION_PUBLISH.format(self.messaging.package_id), time,
motion, self.motion_setpoint)
return True
return False
def _on_temperature_setpoint(self, topic, msg):
self.temperature_setpoint = float(msg)
# We can't do this, because of the stupid recursion depth
# config.set_value("temperature_setpoint", self.temperature_setpoint)
print('Received temperature setpoint {}'.format(msg))
def _on_humidity_setpoint(self, topic, msg):
self.humidity_setpoint = float(msg)
# We can't do this, because of the stupid recursion depth
# config.set_value("humidity_setpoint", self.humidity_setpoint)
print('Received humidity setpoint {}'.format(msg))
def _on_motion_setpoint(self, topic, msg):
self.motion_setpoint = float(msg)
# We can't do this, because of the stupid recursion depth
# config.set_value("motion_setpoint", self.motion_setpoint)
print('Received motion setpoint {}'.format(msg))
class MainWindow(QMainWindow, FormMain):
srv = 'server'
cli = 'client'
clients = {}
servers = {}
downloaded_color = QColor(0xe2, 0xf5, 0xff)
def __init__(self):
QMainWindow.__init__(self)
self.setupUi(self)
if not os.path.exists("DOWNLOADS_PATH"):
os.makedirs("DOWNLOADS_PATH")
if not os.path.exists("TORRENTS_PATH"):
os.makedirs("TORRENTS_PATH")
r = self.geometry()
r.moveCenter(QApplication.desktop().availableGeometry().center())
self.setGeometry(r)
if ("DO_LOGIN"):
self.show_login_form()
self.actions = {
PACKAGE_SENT_ACT: self.on_package_sent_act,
PACKAGE_RECEIVED_ACT: self.on_package_received_act,
SERVER_ADDED_ACT: self.on_server_added_act,
CLIENT_ADDED_ACT: self.on_client_added_act,
SERVER_REMOVED_ACT: self.on_server_removed_act,
CLIENT_REMOVED_ACT: self.on_client_removed_act,
ANSWER_ACT: self.on_answer_act,
FILE_RECEIVED_ACT: self.on_file_received_act,
}
self.cli_thread = Thread(CLI_SOCK_PATH)
self.srv_thread = Thread(SRV_SOCK_PATH)
self.cli_thread.msg_came.connect(self.handle_cli_backend_message)
self.srv_thread.msg_came.connect(self.handle_srv_backend_message)
self.cli_thread.error_came.connect(self.handle_cli_error)
self.srv_thread.error_came.connect(self.handle_srv_error)
self.cli_thread.start()
self.srv_thread.start()
self.tableView_main.rowSelected.connect(self.on_main_table_row_changed)
self.tableView_main.rowDoubleClicked.connect(self.on_row_double_clicked)
self.timer = QTimer(self)
self.connect(self.timer, SIGNAL("timeout()"), self.on_timer)
self.timer.start(100)
self.timer_iteration = 0
self.transmissions = {}
self.expected_response = 0
Logger.log("Старт приложения")
if ("DAEMONIZE"):
self.run_daemons()
self.load_torrents()
def show_login_form(self):
form = LoginWindow(self)
form.show()
def closeEvent(self, e):
Logger.log("Завершение приложения")
self.hide()
self.cli_thread.stop_thread()
self.srv_thread.stop_thread()
def run_daemons(self):
cli = subprocess.Popen("CLI", stdout=subprocess.PIPE,
stderr=subprocess.PIPE, stdin=subprocess.PIPE)
Logger.log("Клиент запущен")
srv = subprocess.Popen("SRV", stdout=subprocess.PIPE,
stderr=subprocess.PIPE, stdin=subprocess.PIPE)
Logger.log("Сервер запущен")
# Actions
def on_package_sent_act(self, data):
cli = self.clients[data['id']]
Logger.log("Часть #{n} файла '{fname}' была отправлена на адрес '{ip}'" \
.format(ip = cli['ip'], n = data['piece_id'], fname = data['file_name']))
key = "{0}-{1}".format(data['id'], data['file_name'])
if key in cli['items']:
cli['items'][key]['sent'] += 1
self.tableView_server.set_packs_sent(cli['items'][key]['sent'], key)
else:
cli['items'][key] = {
'sent': 1,
'last_index': 0,
'name': data['file_name'],
}
self.tableView_server.add_row(key, data['file_name'], cli['ip'], 1)
def on_package_received_act(self, data):
Logger.log("С адреса '{ip}' была получена часть #{n} файла '{fname}'" \
.format(ip = self.servers[data['id']]['ip'], n = data['piece_id'],
fname = self.transmissions[data['hsum']]['filename']))
self.transmissions[data['hsum']]['sent'] += 1
self.tableView_main.set_packs_sent(packs = self.transmissions[data['hsum']]['sent'], key = data['hsum'])
prc = self.transmissions[data['hsum']]['filesize']
prc = self.transmissions[data['hsum']]['sent'] * PIECE_LEN / prc
self.tableView_main.set_perc_sent(prc * 100 if prc < 1 else 100.0, data['hsum'])
self.statusWidget.add_line(data['hsum'], data['piece_id'],
self.servers[data['id']]['color'])
s = self.servers[data['id']]
s['sent'] += 1
self.tableView_client.set_packs_sent(s['sent'], s['ip'])
def on_server_added_act(self, data):
Logger.log("Подключен сервер '{ip}'".format(ip = data['ip']))
self.servers[data['id']] = {
'ip': data['ip'],
'sent': 0,
'last_index': 0,
'color': QColor.fromHsv(random.randint(0, 359), 220, 190),
}
self.tableView_client.add_row(data['ip'])
def on_client_added_act(self, data):
Logger.log("Подключен клиент '{ip}'".format(ip = data['ip']))
self.clients[data['id']] = {
'ip': data['ip'],
'items': {},
}
def on_server_removed_act(self, data):
Logger.log("Сервер '{ip}' отключился".format(ip = self.servers[data['id']]['ip']))
self.tableView_client.remove_row(self.servers[data['id']]['ip'])
del self.servers[data['id']]
def on_client_removed_act(self, data):
Logger.log("Клиент '{ip}' отключился".format(ip = self.clients[data['id']]['ip']))
for key in self.clients[data['id']]['items']:
self.tableView_server.remove_row(key)
del self.clients[data['id']]
def on_answer_act(self, data):
r = int(data['result'])
text = ''
if r != 0:
text = ": возникла ошибка {e}".format(e = data['error'])
if data['error'] == FILE_RECEIVING_FAILURE:
self.on_actionStop_transmission_triggered(data['hsum'])
Logger.log("Результат выполнения операции: {r}{text}".format(r = r, text = text))
if r == -1:
QMessageBox.information(self, "Ошибка",
"Торрент файл не может быть загружен -- нет активных серверов")
if 'act' in data and 'hsum' in data and data['hsum'] in self.transmissions:
trm = self.transmissions[data['hsum']]
if (data['act'] == STOP_TRM_ACT and r == 0) or (data['act'] == START_TRM_ACT and r != 0):
trm['sent'] = trm['active'] = trm['finished'] = 0
elif data['act'] == START_TRM_ACT:
trm['trmid'] = data['trmid']
trm['active'] = 1
self.on_main_table_row_changed(data['hsum'])
def on_file_received_act(self, data):
s = data['hsum']
struct = self.transmissions[s]
Logger.log("Файл '{name}' был полностью получен".format(name = struct['filename']))
self.create_torrent_file(struct['filename'], struct['filesize'],
data['hsum'], "DOWNLOADS_PATH/" + struct['filename'])
self.load_torrent(fname = "TORRENTS_PATH/" + s, add_row = False)
struct['sent'] = -1
struct['active'] = 0
struct['finished'] = 1
self.on_main_table_row_changed(s)
def handle_srv_error(self, class_name, msg = None):
Logger.log("Возникла ошибка в потоке сервера{msg}" \
.format(msg = ": " + msg if msg else ""))
return self.handle_error(class_name, msg, self.srv)
def handle_cli_error(self, class_name, msg = None):
Logger.log("Возникла ошибка в потоке клиента{msg}" \
.format(msg = ": " + msg if msg else ""))
return self.handle_error(class_name, msg, self.cli)
def handle_srv_backend_message(self, msg):
return self.handle_backend_message(msg, self.srv)
def handle_cli_backend_message(self, msg):
return self.handle_backend_message(msg, self.cli)
def handle_error(self, class_name, msg = None, sender = None):
QMessageBox.information(self, 'Ошибка', \
'Возникла ошибка в потоке "{thread}": {msg}'.format( \
thread = (sender == self.srv and 'Сервер') or \
(sender == self.cli and 'Клиент') or \
'Неизвестно', \
msg = msg), QMessageBox.Ok)
def handle_backend_message(self, msg, sender = None):
try:
self.__handle_backend_message(msg, sender)
except MainError as e:
self.handle_error(type(e).__name__, e.args[0])
def __handle_backend_message(self, msg, sender = None):
data = json.loads(msg, encoding='utf-8')
return self.actions[data['action']](data)
def load_torrent(self, fname = None, sent = -1, hsum = None, filename = None,
filesize = None, add_row = True):
if fname:
with open(fname, "rb") as f:
struct = pickle.load(f)
if 'default_path' in struct:
sent = -1
else:
sent = 0
return self.load_torrent(sent = sent, hsum = struct['hsum'],
filename = struct['filename'], filesize = struct['filesize'],
add_row = add_row)
if not os.path.isfile("TORRENTS_PATH/" + hsum):
self.create_torrent_file(filename, filesize, hsum)
if type(filesize) != int:
filesize = int(filesize)
pieces_count = math.ceil(filesize / PIECE_LEN)
Logger.log("Был загружен торрент файл для файла '{name}'{status}" \
.format(name = filename, status = ", статус: загружен" if sent == -1 else ""))
save = {
'filename': filename,
'filesize': filesize,
'active': 0,
'sent': sent,
'last_index': sent,
}
if (sent == -1):
save['finished'] = 1
else:
save['finished'] = 0
self.transmissions[hsum] = save
if add_row:
self.tableView_main.add_row(hsum = hsum, name = filename, packs = pieces_count, sent = sent)
self.statusWidget.init_elem(hsum, pieces_count)
if sent == -1:
self.statusWidget.add_rect(hsum, 0, pieces_count - 1, self.downloaded_color)
def load_torrents(self):
for fname in glob.glob("TORRENTS_PATH/*"):
self.load_torrent(fname = fname)
def create_torrent_file(self, filename, filesize, hsum, fname = None):
if type(filesize) != str:
filesize = str(filesize)
struct = {'filesize': filesize, 'hsum': hsum, 'filename': filename}
if fname:
struct['default_path'] = fname
fname = "TORRENTS_PATH/" + hsum
Logger.log("Был создан торрент файл для файла '{name}'" \
.format(name = filename))
with open(fname, 'wb') as f:
pickle.dump(struct, f, 0)
def update_speed(self):
count_speed = lambda delta: delta * PIECE_LEN / 1024.0
for key, e in self.transmissions.items():
delta = e['sent'] - e['last_index']
self.tableView_main.set_speed(count_speed(delta), key)
e['last_index'] = e['sent']
for e in self.servers.values():
delta = e['sent'] - e['last_index']
self.tableView_client.set_speed(count_speed(delta), e['ip'])
e['last_index'] = e['sent']
for e in self.clients.values():
for key, value in e['items'].items():
delta = value['sent'] - value['last_index']
self.tableView_server.set_speed(count_speed(delta), key)
value['last_index'] = value['sent']
@pyqtSlot()
def on_actionStart_transmission_triggered(self):
key = self.tableView_main.current_row
if not key:
return
s = self.transmissions[key]
if not s['finished']:
Logger.log("Отправлен запрос на получение файла '{name}'" \
.format(name = s['filename']))
self.cli_thread.send_message({'action': START_TRM_ACT,
'hsum': key, 'filename': s['filename'], 'filesize': str(s['filesize'])})
@pyqtSlot()
def on_actionCreate_transmission_triggered(self):
fname = QFileDialog.getOpenFileName(self, 'Open file to create a torrent', '~')
if fname:
hsum = hashlib.md5(open(fname, "rb").read()).hexdigest()
if not os.path.exists("TORRENTS_PATH/" + hsum):
self.create_torrent_file(ntpath.basename(fname), os.path.getsize(fname), hsum, fname)
self.load_torrent(fname = "TORRENTS_PATH/" + hsum)
else:
Logger.log("Торрент файл {0} уже существует".format(fname))
QMessageBox.information(self, 'Ошибка',
'Торрент файл уже существует', QMessageBox.Ok)
@pyqtSlot()
def on_actionRemove_transmission_triggered(self):
key = self.tableView_main.current_row
if not key:
return
if self.transmissions[key]['active']:
self.on_actionStop_transmission_triggered()
self.tableView_main.remove_row(key)
try:
os.remove("TORRENTS_PATH/" + key)
except OSError:
pass
Logger.log("Торрен файл для файла '{name}' был удален" \
.format(name = self.transmissions[key]['filename']))
del self.transmissions[key]
@pyqtSlot()
def on_actionStop_transmission_triggered(self, key = None):
if not key:
key = self.tableView_main.current_row
s = self.transmissions[key]
if s['active']:
Logger.log("Отправлен запрос на остановку получения файла '{name}'" \
.format(name = s['filename']))
self.cli_thread.send_message({'action': STOP_TRM_ACT, 'filename': s['filename'],
'hsum': key, 'filesize': str(s['filesize']), 'trmid': s['trmid']})
self.transmissions[key]['active'] = 0
self.statusWidget.remove_lines(key)
self.on_main_table_row_changed(key)
s['active'] = s['finished'] = s['sent'] = 0
@pyqtSlot('QString')
def on_main_table_row_changed(self, key):
if self.transmissions[key]['active']:
self.actionStop_transmission.setEnabled(True)
self.actionStart_transmission.setEnabled(False)
else:
self.actionStop_transmission.setEnabled(False)
self.actionStart_transmission.setEnabled(self.transmissions[key]['sent'] != -1)
self.actionRemove_transmission.setEnabled(True)
self.statusWidget.current_elem = key
@pyqtSlot('QString')
def on_row_double_clicked(self, key):
form = TorrentWindow(self)
s = self.transmissions[key]
form.size_edit.setText(str(s['filesize']))
form.sum_edit.setText(key)
form.name_edit.setText(s['filename'])
form.save_btn.setVisible(False)
form.show()
@pyqtSlot()
def on_actionAdd_torrent_triggered(self):
form = TorrentWindow(self)
form.size_edit.setReadOnly(False)
form.sum_edit.setReadOnly(False)
form.name_edit.setReadOnly(False)
form.save_btn.clicked.connect(self.add_remote_torrent)
self.current_torrent_form = form
form.show()
@pyqtSlot()
def on_action_showLogs_triggered(self):
form = LogsWindow(self)
form.set_logs(Logger.get_log())
form.show()
@pyqtSlot()
def on_actionAbout_triggered(self):
form = AboutWindow(self)
form.show()
@pyqtSlot()
def on_timer(self):
speed_time = 10
status_w_time = 3
table_w_time = 5
if self.timer_iteration % speed_time == 0:
self.update_speed()
if self.timer_iteration % status_w_time == 0:
self.statusWidget.repaint()
if self.timer_iteration % table_w_time == 0:
self.tableView_main.update_values()
self.tableView_client.update_values()
self.tableView_server.update_values()
if self.timer_iteration > 100 * speed_time * status_w_time * table_w_time:
self.timer_iteration = 0
self.timer_iteration += 1
@pyqtSlot(QEvent)
def add_remote_torrent(self):
form = self.current_torrent_form
if (len(form.sum_edit.text()) != 32):
QMessageBox.information(self, 'Ошибка',
'Необходимо указать корректную MD5 сумму файла', QMessageBox.Ok)
else:
form.close()
self.load_torrent(filename = form.name_edit.text(),
filesize = form.size_edit.text(), sent = 0,
hsum = form.sum_edit.text())
def __init__(self, params_pipe, number_pipe, data_pipe, mads_pipe, peaks_pipe,
probe_path=None, screen_resolution=None):
QMainWindow.__init__(self)
# Receive parameters.
params = params_pipe[0].recv()
self.probe = load_probe(probe_path)
self._nb_samples = params['nb_samples']
self._sampling_rate = params['sampling_rate']
self._display_list = list(range(self.probe.nb_channels))
self._params = {
'nb_samples': self._nb_samples,
'sampling_rate': self._sampling_rate,
'time': {
'min': 10.0, # ms
'max': 1000.0, # ms
'init': 100.0, # ms
},
'voltage': {
'min': 10.0, # µV
'max': 10e+3, # µV
'init': 20.0, # µV
},
'mads': {
'min': 0.0, # µV
'max': 100, # µV
'init': 3, # µV
},
'channels': self._display_list
}
self._canvas = TraceCanvas(probe_path=probe_path, params=self._params)
central_widget = self._canvas.native
# Create controls widgets.
label_time = QLabel()
label_time.setText(u"time")
label_time_unit = QLabel()
label_time_unit.setText(u"ms")
self._dsp_time = QDoubleSpinBox()
self._dsp_time.setMinimum(self._params['time']['min'])
self._dsp_time.setMaximum(self._params['time']['max'])
self._dsp_time.setValue(self._params['time']['init'])
self._dsp_time.valueChanged.connect(self._on_time_changed)
label_display_mads = QLabel()
label_display_mads.setText(u"Display Mads")
self._display_mads = QCheckBox()
self._display_mads.stateChanged.connect(self._on_mads_display)
label_display_peaks = QLabel()
label_display_peaks.setText(u"Display Peaks")
self._display_peaks = QCheckBox()
self._display_peaks.stateChanged.connect(self._on_peaks_display)
label_mads = QLabel()
label_mads.setText(u"Mads")
label_mads_unit = QLabel()
label_mads_unit.setText(u"unit")
self._dsp_mads = QDoubleSpinBox()
self._dsp_mads.setMinimum(self._params['mads']['min'])
self._dsp_mads.setMaximum(self._params['mads']['max'])
self._dsp_mads.setValue(self._params['mads']['init'])
self._dsp_mads.valueChanged.connect(self._on_mads_changed)
label_voltage = QLabel()
label_voltage.setText(u"voltage")
label_voltage_unit = QLabel()
label_voltage_unit.setText(u"µV")
self._dsp_voltage = QDoubleSpinBox()
self._dsp_voltage.setMinimum(self._params['voltage']['min'])
self._dsp_voltage.setMaximum(self._params['voltage']['max'])
self._dsp_voltage.setValue(self._params['voltage']['init'])
self._dsp_voltage.valueChanged.connect(self._on_voltage_changed)
# Color spikes
self._color_spikes = QCheckBox()
self._color_spikes.setText('See Spikes color')
self._color_spikes.setCheckState(Qt.Checked)
self._color_spikes.stateChanged.connect(self.display_spikes_color)
# self._selection_channels.setGeometry(QtCore.QRect(10, 10, 211, 291))
spacer = QSpacerItem(20, 40, QSizePolicy.Minimum, QSizePolicy.Expanding)
# Create controls grid.
grid = QGridLayout()
# # Add time row.
grid.addWidget(label_time, 0, 0)
grid.addWidget(self._dsp_time, 0, 1)
grid.addWidget(label_time_unit, 0, 2)
# # Add voltage row.
grid.addWidget(label_voltage, 1, 0)
grid.addWidget(self._dsp_voltage, 1, 1)
grid.addWidget(label_voltage_unit, 1, 2)
# # Add Mads widgets
grid.addWidget(label_display_mads, 3, 0)
grid.addWidget(self._display_mads, 3, 1)
grid.addWidget(label_mads, 4, 0)
grid.addWidget(self._dsp_mads, 4, 1)
grid.addWidget(label_mads_unit, 4, 2)
grid.addWidget(self._color_spikes, 5, 0)
# # Add spacer.
grid.addItem(spacer)
# # Create info group.
controls_group = QGroupBox()
controls_group.setLayout(grid)
self._selection_channels = QListWidget()
self._selection_channels.setSelectionMode(
QAbstractItemView.ExtendedSelection
)
for i in range(self.probe.nb_channels):
item = QListWidgetItem("Channel %i" % i)
self._selection_channels.addItem(item)
self._selection_channels.item(i).setSelected(True)
def add_channel():
items = self._selection_channels.selectedItems()
self._display_list = []
for i in range(len(items)):
self._display_list.append(i)
self._on_channels_changed()
# self._selection_channels.itemClicked.connect(add_channel)
nb_channel = self.probe.nb_channels
self._selection_channels.itemSelectionChanged.connect(lambda: self.selected_channels(nb_channel))
# Create info grid.
channels_grid = QGridLayout()
# # Add Channel selection
# grid.addWidget(label_selection, 3, 0)
channels_grid.addWidget(self._selection_channels, 0, 1)
# # Add spacer.
channels_grid.addItem(spacer)
# Create controls group.
channels_group = QGroupBox()
channels_group.setLayout(channels_grid)
# # Create controls dock.
channels_dock = QDockWidget()
channels_dock.setWidget(channels_group)
channels_dock.setWindowTitle("Channels selection")
# # Create controls dock.
control_dock = QDockWidget()
control_dock.setWidget(controls_group)
control_dock.setWindowTitle("Controls")
# Create info widgets.
label_time = QLabel()
label_time.setText(u"time")
self._label_time_value = QLineEdit()
self._label_time_value.setText(u"0")
self._label_time_value.setReadOnly(True)
self._label_time_value.setAlignment(Qt.AlignRight)
label_time_unit = QLabel()
label_time_unit.setText(u"s")
info_buffer_label = QLabel()
info_buffer_label.setText(u"buffer")
self._info_buffer_value_label = QLineEdit()
self._info_buffer_value_label.setText(u"0")
self._info_buffer_value_label.setReadOnly(True)
self._info_buffer_value_label.setAlignment(Qt.AlignRight)
info_buffer_unit_label = QLabel()
info_buffer_unit_label.setText(u"")
info_probe_label = QLabel()
info_probe_label.setText(u"probe")
info_probe_value_label = QLineEdit()
info_probe_value_label.setText(u"{}".format(probe_path))
info_probe_value_label.setReadOnly(True)
# TODO place the following info in another grid?
info_probe_unit_label = QLabel()
info_probe_unit_label.setText(u"")
info_spacer = QSpacerItem(20, 40, QSizePolicy.Minimum, QSizePolicy.Expanding)
# Create info grid.
info_grid = QGridLayout()
# # Time row.
info_grid.addWidget(label_time, 0, 0)
info_grid.addWidget(self._label_time_value, 0, 1)
info_grid.addWidget(label_time_unit, 0, 2)
# # Buffer row.
info_grid.addWidget(info_buffer_label, 1, 0)
info_grid.addWidget(self._info_buffer_value_label, 1, 1)
info_grid.addWidget(info_buffer_unit_label, 1, 2)
# # Probe row.
info_grid.addWidget(info_probe_label, 2, 0)
info_grid.addWidget(info_probe_value_label, 2, 1)
info_grid.addWidget(info_probe_unit_label, 2, 2)
# # Spacer.
info_grid.addItem(info_spacer)
# Create info group.
info_group = QGroupBox()
info_group.setLayout(info_grid)
# Create info dock.
info_dock = QDockWidget()
info_dock.setWidget(info_group)
info_dock.setWindowTitle("Info")
# Create thread.
thread = Thread(number_pipe, data_pipe, mads_pipe, peaks_pipe)
thread.number_signal.connect(self._number_callback)
thread.reception_signal.connect(self._reception_callback)
thread.start()
# Add dockable windows.
self.addDockWidget(Qt.LeftDockWidgetArea, control_dock)
self.addDockWidget(Qt.LeftDockWidgetArea, info_dock)
self.addDockWidget(Qt.LeftDockWidgetArea, channels_dock)
# Set central widget.
self.setCentralWidget(central_widget)
# Set window size.
if screen_resolution is not None:
screen_width = screen_resolution.width()
screen_height = screen_resolution.height()
self.resize(screen_width, screen_height)
# Set window title.
self.setWindowTitle("SpyKING Circus ORT - Read 'n' Qt display")
print(" ") # TODO remove?
def __init__(self, params_pipe, number_pipe, templates_pipe, spikes_pipe,
probe_path=None, screen_resolution=None):
QMainWindow.__init__(self)
# Receive parameters.
params = params_pipe[0].recv()
self.probe = load_probe(probe_path)
self._nb_samples = params['nb_samples']
self._sampling_rate = params['sampling_rate']
self._display_list = []
self._params = {
'nb_samples': self._nb_samples,
'sampling_rate': self._sampling_rate,
'time': {
'min': 10.0, # ms
'max': 100.0, # ms
'init': 100.0, # ms
},
'voltage': {
'min': -200, # µV
'max': 20e+1, # µV
'init': 50.0, # µV
},
'templates': self._display_list
}
self._canvas_mea = MEACanvas(probe_path=probe_path, params=self._params)
self._canvas_template = TemplateCanvas(probe_path=probe_path, params=self._params)
self._canvas_rate = RateCanvas(probe_path=probe_path, params=self._params)
self._canvas_isi = ISICanvas(probe_path=probe_path, params=self._params)
self.cells = Cells({})
self._nb_buffer = 0
# TODO ISI
self.isi_bin_width, self.isi_x_max = 2, 25.0
canvas_template_widget = self._canvas_template.native
canvas_mea = self._canvas_mea.native
canvas_rate = self._canvas_rate.native
canvas_isi = self._canvas_isi.native
# Create controls widgets.
label_time = QLabel()
label_time.setText(u"time")
label_time_unit = QLabel()
label_time_unit.setText(u"ms")
self._dsp_time = QDoubleSpinBox()
self._dsp_time.setMinimum(self._params['time']['min'])
self._dsp_time.setMaximum(self._params['time']['max'])
self._dsp_time.setValue(self._params['time']['init'])
self._dsp_time.valueChanged.connect(self._on_time_changed)
label_voltage = QLabel()
label_voltage.setText(u"voltage")
label_voltage_unit = QLabel()
label_voltage_unit.setText(u"µV")
self._dsp_voltage = QDoubleSpinBox()
self._dsp_voltage.setMinimum(self._params['voltage']['min'])
self._dsp_voltage.setMaximum(self._params['voltage']['max'])
self._dsp_voltage.setValue(self._params['voltage']['init'])
self._dsp_voltage.valueChanged.connect(self._on_voltage_changed)
label_binsize = QLabel()
label_binsize.setText(u"Bin size")
label_binsize_unit = QLabel()
label_binsize_unit.setText(u"second")
self._dsp_binsize = QDoubleSpinBox()
self._dsp_binsize.setRange(0.1, 10)
self._dsp_binsize.setSingleStep(0.1)
self.bin_size = 1
self._dsp_binsize.setValue(self.bin_size)
self._dsp_binsize.valueChanged.connect(self._on_binsize_changed)
label_zoomrates = QLabel()
label_zoomrates.setText(u'Zoom rates')
self._zoom_rates = QDoubleSpinBox()
self._zoom_rates.setRange(1, 50)
self._zoom_rates.setSingleStep(0.1)
self._zoom_rates.setValue(1)
self._zoom_rates.valueChanged.connect(self._on_zoomrates_changed)
label_time_window = QLabel()
label_time_window.setText(u'Time window rates')
label_time_window_unit = QLabel()
label_time_window_unit.setText(u'second')
self._dsp_tw_rate = QDoubleSpinBox()
self._dsp_tw_rate.setRange(1, 50)
self._dsp_tw_rate.setSingleStep(self.bin_size)
self._dsp_tw_rate.setValue(50 * self.bin_size)
self._dsp_tw_rate.valueChanged.connect(self._on_time_window_changed)
label_tw_from_start = QLabel()
label_tw_from_start.setText('Time scale from start')
self._tw_from_start = QCheckBox()
self._tw_from_start.setChecked(True)
self._selection_templates = QTableWidget()
self._selection_templates.setSelectionMode(
QAbstractItemView.ExtendedSelection
)
self._selection_templates.setColumnCount(3)
self._selection_templates.setVerticalHeaderLabels(['Nb template', 'Channel', 'Amplitude'])
self._selection_templates.insertRow(0)
self._selection_templates.setItem(0, 0, QTableWidgetItem('Nb template'))
self._selection_templates.setItem(0, 1, QTableWidgetItem('Channel'))
self._selection_templates.setItem(0, 2, QTableWidgetItem('Amplitude'))
# self._selection_channels.setGeometry(QtCore.QRect(10, 10, 211, 291))
# for i in range(self.nb_templates):
# numRows = self.tableWidget.rowCount()
# self.tableWidget.insertRow(numRows)
# item = QTableWidgetItem("Template %i" % i)
# self._selection_templates.addItem(item)
# self._selection_templates.item(i).setSelected(False)
spacer = QSpacerItem(20, 40, QSizePolicy.Minimum, QSizePolicy.Expanding)
# Create controls grid.
grid = QGridLayout()
# # Add time row.
grid.addWidget(label_time, 0, 0)
grid.addWidget(self._dsp_time, 0, 1)
grid.addWidget(label_time_unit, 0, 2)
# # Add voltage row.
grid.addWidget(label_voltage, 1, 0)
grid.addWidget(self._dsp_voltage, 1, 1)
grid.addWidget(label_voltage_unit, 1, 2)
# # Add binsize row.
grid.addWidget(label_binsize, 2, 0)
grid.addWidget(self._dsp_binsize, 2, 1)
grid.addWidget(label_binsize_unit, 2, 2)
# # Add zoom rate
grid.addWidget(label_zoomrates, 3, 0)
grid.addWidget(self._zoom_rates, 3, 1)
# Add a double checkbox for time window
grid.addWidget(label_time_window, 4, 0)
grid.addWidget(self._dsp_tw_rate, 4, 1)
grid.addWidget(label_time_window_unit, 4, 2)
## Add checkbox to display the rates from start
grid.addWidget(label_tw_from_start, 5, 0)
grid.addWidget(self._tw_from_start, 5, 1)
# # Add spacer.
grid.addItem(spacer)
# # Create info group.
controls_group = QGroupBox()
controls_group.setLayout(grid)
# Create info grid.
templates_grid = QGridLayout()
# # Add Channel selection
# grid.addWidget(label_selection, 3, 0)
templates_grid.addWidget(self._selection_templates, 0, 1)
def add_template():
items = self._selection_templates.selectedItems()
self._display_list = []
for i in range(len(items)):
self._display_list.append(i)
self._on_templates_changed()
# self._selection_templates.itemClicked.connect(add_template)
# Template selection signals
self._selection_templates.itemSelectionChanged.connect(lambda: self.selected_templates(
self.nb_templates))
# Checkbox to display all the rates
self._tw_from_start.stateChanged.connect(self.time_window_rate_full)
# self._selection_templates.itemPressed(0, 1).connect(self.sort_template())
# # Add spacer.
templates_grid.addItem(spacer)
# Create controls group.
templates_group = QGroupBox()
templates_group.setLayout(templates_grid)
# # Create controls dock.
templates_dock = QDockWidget()
templates_dock.setWidget(templates_group)
templates_dock.setWindowTitle("Channels selection")
# # Create controls dock.
control_dock = QDockWidget()
control_dock.setWidget(controls_group)
control_dock.setWindowTitle("Controls")
# Create info widgets.
label_time = QLabel()
label_time.setText(u"time")
self._label_time_value = QLineEdit()
self._label_time_value.setText(u"0")
self._label_time_value.setReadOnly(True)
self._label_time_value.setAlignment(Qt.AlignRight)
label_time_unit = QLabel()
label_time_unit.setText(u"s")
info_buffer_label = QLabel()
info_buffer_label.setText(u"buffer")
self._info_buffer_value_label = QLineEdit()
self._info_buffer_value_label.setText(u"0")
self._info_buffer_value_label.setReadOnly(True)
self._info_buffer_value_label.setAlignment(Qt.AlignRight)
info_buffer_unit_label = QLabel()
info_buffer_unit_label.setText(u"")
info_probe_label = QLabel()
info_probe_label.setText(u"probe")
info_probe_value_label = QLineEdit()
info_probe_value_label.setText(u"{}".format(probe_path))
info_probe_value_label.setReadOnly(True)
# TODO place the following info in another grid?
info_probe_unit_label = QLabel()
info_probe_unit_label.setText(u"")
info_spacer = QSpacerItem(20, 40, QSizePolicy.Minimum, QSizePolicy.Expanding)
# Create info grid.
info_grid = QGridLayout()
# # Time row.
info_grid.addWidget(label_time, 0, 0)
info_grid.addWidget(self._label_time_value, 0, 1)
info_grid.addWidget(label_time_unit, 0, 2)
# # Buffer row.
info_grid.addWidget(info_buffer_label, 1, 0)
info_grid.addWidget(self._info_buffer_value_label, 1, 1)
info_grid.addWidget(info_buffer_unit_label, 1, 2)
# # Probe row.
info_grid.addWidget(info_probe_label, 2, 0)
info_grid.addWidget(info_probe_value_label, 2, 1)
info_grid.addWidget(info_probe_unit_label, 2, 2)
# # Spacer.
info_grid.addItem(info_spacer)
# Create info group.
info_group = QGroupBox()
info_group.setLayout(info_grid)
# Create info dock.
info_dock = QDockWidget()
info_dock.setWidget(info_group)
info_dock.setWindowTitle("Info")
# Create thread.
thread = Thread(number_pipe, templates_pipe, spikes_pipe)
thread.number_signal.connect(self._number_callback)
thread.reception_signal.connect(self._reception_callback)
thread.start()
# Add dockable windows.
self.addDockWidget(Qt.LeftDockWidgetArea, control_dock)
self.addDockWidget(Qt.LeftDockWidgetArea, info_dock)
self.addDockWidget(Qt.LeftDockWidgetArea, templates_dock)
# Add Grid Layout for canvas
canvas_grid = QGridLayout()
group_canv_temp = QDockWidget()
group_canv_temp.setWidget(canvas_template_widget)
group_canv_mea = QDockWidget()
group_canv_mea.setWidget(canvas_mea)
group_canv_rate = QDockWidget()
group_canv_rate.setWidget(canvas_rate)
group_canv_isi = QDockWidget()
group_canv_isi.setWidget(canvas_isi)
canvas_grid.addWidget(group_canv_temp, 0, 0)
canvas_grid.addWidget(group_canv_mea, 0, 1)
canvas_grid.addWidget(group_canv_rate, 1, 1)
canvas_grid.addWidget(group_canv_isi, 1, 0)
canvas_group = QGroupBox()
canvas_group.setLayout(canvas_grid)
# Set central widget.
self.setCentralWidget(canvas_group)
# Set window size.
if screen_resolution is not None:
screen_width = screen_resolution.width()
screen_height = screen_resolution.height()
self.resize(screen_width, screen_height)
# Set window title.
self.setWindowTitle("SpyKING Circus ORT - Read 'n' Qt display")
print(" ") # TODO remove?
class MessagingService:
"""
For transmitting messages out of the device, and buffering them locally in
case a transmission channel is unavailable - such as missing Wifi.
The messaging service can be in one of two possible states:
- Waiting: The service is dormant, waiting for new messages or a channel to
become available.
- Transmitting: The service is currently transmitting messages.
When the local message buffer is empty, the messaging service will enter
the waiting state until explicitly notified of new messages. If any
messages are available, the service will attempt to transmit them every ten
minutes, or sooner if explicitly notified.
Channels are themselves reponsible for ensuring thread safety. For
instance, a channel might disallow buffering new messages during an active
transmission.
"""
def __init__(self, wifi: Wifi, oled):
self.wifi = wifi
self.channels = []
self.oled = oled
self.package_id = config.get_string("package_id")
self.thread = Thread(self.__messaging_loop, "MessageThread")
# Semaphore for signaling the messaging service
self._message_semaphore = _thread.allocate_lock()
# Lock for protecting critical regions
self._sync_lock = ReentrantLock()
def start(self):
self.thread.start()
def notify(self):
"""
Notify the messaging service to begin transmitting messages again. If
the messaging service is currently in a waiting state, calling this
method will restart it. The messaging service will return to a waiting
state as soon as all pending messages have been transmitted, or
channels become unavailable.
"""
if self._message_semaphore.locked():
self._message_semaphore.release()
def __messaging_loop(self, thread: Thread):
# This exception handling is necessary in order for background threads
# to be affected by keyboard interrupts and to print stack traces in
# case of exceptions.
while thread.active:
# There is no concept of a thread holding a lock with the _thread
# library. A lock is either locked or unlocked, and if the same
# thread attempts to acquire the same lock twice, it will block
# itself until someone else calls release on the lock.
if self.__has_pending_messages():
# While there are pending messages, retry every thirty seconds
self._message_semaphore.acquire(1, 30)
else:
# Otherwise wait for an explicit signal
self._message_semaphore.acquire()
self._sync_lock.acquire()
try:
if not self.__has_pending_messages():
continue
for channel in self.channels:
channel.transmit()
finally:
# In case Wifi was enabled, deactivate it now to save energy
self.wifi.deactivate()
self._sync_lock.release()
def __has_pending_messages(self) -> bool:
"""Check if any channels have pending messages. Not thread safe."""
for channel in self.channels:
if channel.has_pending_messages:
return True
return False
def add_channel(self, channel):
"""
Add a new object to be used for transmitting messages out of the
device.
"""
self._sync_lock.acquire()
try:
self.channels.append(channel)
finally:
self._sync_lock.release()
class MainWindow(QMainWindow):
send_control_init = QtCore.pyqtSignal(list, float)
send_data_result = QtCore.pyqtSignal(list, float, list)
send_construct_save = QtCore.pyqtSignal(int, list)
send_plotConst = QtCore.pyqtSignal(list)
send_plotXYZtheta = QtCore.pyqtSignal(list, list)
send_thread = QtCore.pyqtSignal(float, list)
send_thread2 = QtCore.pyqtSignal(float, list, list)
send_sequenceActual = QtCore.pyqtSignal(list)
send_sequenceSim = QtCore.pyqtSignal(int)
send_sequenceSetAct = QtCore.pyqtSignal(int)
send_thread2Reset = QtCore.pyqtSignal(int)
def __init__(self):
super().__init__()
self.kardan_min = -150
self.kardan_max = -60
self.online = False
self.torqueState = False
self.select = 0
self.dataList = [[], [], [], [], [], []]
self.xyz = [0.0, 0.0, -100]
self.alpha = 0.0
self.theta = [0.0, 0.0, 0.0]
self.sym = 0
self.presAngle = []
self.sequenceList = [0.0, 0.0, 0.0, 0.0, 0.0]
self.speed = 10.0
self.sequenceStatus = 0
self.sequenceCount = 0
self.kardanStatus = 0
self.initWindow()
self.dockWidget()
self.show()
settings = QSettings('construct')
select_getSave = settings.value('select1', type=int)
for i in range(len(self.dataList)):
self.dataList[i] = settings.value('list' + str(i), 1024)
if self.dataList[0] != 1024:
self.send_construct_save.emit(select_getSave, self.dataList)
try:
sequenceListSave = QSettings('SequenceList')
self.sequenceData = sequenceListSave.value('select2', list)
if self.sequenceData != None:
for i in range(len(self.sequenceData)):
self.send_sequenceActual.emit(self.sequenceData[i])
except:
print("error")
self.git_thread = Thread(self)
self.git_thread.send_actualPoseT.connect(self.dataFromThread)
self.git_thread.send_visialisation.connect(self.Visual)
self.git_thread.send_finish.connect(self.dynamixelFinish)
self.git_thread.start()
def dataFromThread(self, presAngleT):
self.xyz = forward(presAngleT, self.dataListActual)
self.presAngle = presAngleT
self.send_data_result.emit(self.xyz, self.presAngle[3], self.presAngle)
def Visual(self, xyz, theta):
self.send_plotXYZtheta.emit(xyz, theta)
if self.sequenceStatus == 1:
self.send_data_result.emit(self.xyz, self.alpha, self.theta)
def initWindow(self):
self.setWindowTitle("Delta Robot Studio")
self.setGeometry(0, 0, 790, 470)
#self.setMaximumSize(790, 470)
#self.showMaximized()
mainMenu = self.menuBar()
windowMenu = mainMenu.addMenu('Window')
motorMenu = mainMenu.addMenu('Connect motors')
kardanMenu = mainMenu.addMenu('Cardan Joint')
self.mainLayout = QHBoxLayout()
constructWindow = QAction('Construct', self, checkable=True)
constructWindow.setChecked(True)
constructWindow.triggered.connect(self.constructWindow)
windowMenu.addAction(constructWindow)
controlWindow = QAction('Control', self, checkable=True)
controlWindow.setChecked(True)
controlWindow.triggered.connect(self.controlWindow)
windowMenu.addAction(controlWindow)
resultWindow = QAction('Result', self, checkable=True)
resultWindow.setChecked(True)
resultWindow.triggered.connect(self.resultWindow)
windowMenu.addAction(resultWindow)
sequToolWindow = QAction('Sequence tool', self, checkable=True)
sequToolWindow.setChecked(True)
sequToolWindow.triggered.connect(self.sequToolWindow)
windowMenu.addAction(sequToolWindow)
sequWindow = QAction('Sequence', self, checkable=True)
sequWindow.setChecked(True)
sequWindow.triggered.connect(self.sequWindow)
windowMenu.addAction(sequWindow)
self.onlineWindow = QAction('Online', self, checkable=True)
self.onlineWindow.setChecked(False)
self.onlineWindow.triggered.connect(self.onlineWindowDef)
motorMenu.addAction(self.onlineWindow)
self.torqueWindow = QAction('Motor torque', self, checkable=True)
self.torqueWindow.setChecked(False)
self.torqueWindow.triggered.connect(self.torqueWindowDef)
motorMenu.addAction(self.torqueWindow)
kardanEnable = QAction('Cardan Joint', self, checkable=True)
kardanEnable.setChecked(False)
kardanEnable.triggered.connect(self.kardanEnable)
kardanMenu.addAction(kardanEnable)
self.kardan_set = QAction('Cardan settings', self, checkable=False)
self.kardan_set.triggered.connect(self.kardanSettings)
kardanMenu.addAction(self.kardan_set)
def kardanSettings(self, state):
min, okPressed = QInputDialog.getDouble(self, "Cardan settings",
"minimal position:",
self.kardan_min, -1000, 0, 2)
if okPressed:
self.kardan_min = min
max, okPressed = QInputDialog.getDouble(self, "Cardan settings",
"maximal position:",
self.kardan_max, -1000, 0, 2)
if okPressed:
self.kardan_max = max
def kardanEnable(self, state):
if state: self.kardanStatus = 1
else: self.kardanStatus = 0
def constructWindow(self, state):
if state: self.dockConstruct.show()
else: self.dockConstruct.hide()
def controlWindow(self, state):
if state: self.dockControl.show()
else: self.dockControl.hide()
def resultWindow(self, state):
if state: self.dockDataResult.show()
else: self.dockDataResult.hide()
def sequToolWindow(self, state):
if state: self.dockSequenceTool.show()
else: self.dockSequenceTool.hide()
def sequWindow(self, state):
if state: self.dockSequence.show()
else: self.dockSequence.hide()
def onlineWindowDef(self, state):
if state:
try:
init()
self.online = True
self.central_widget.addWidget(self.dockSequenceItem)
self.central_widget.setCurrentWidget(self.dockSequenceItem)
self.dockSequence.hide()
self.send_sequenceSim.emit(0)
QMessageBox.about(self, "Succes", "Online mode enable")
except:
QMessageBox.about(self, "Warning", "Connect converter to port")
self.onlineWindow.setChecked(False)
else:
try:
close()
self.online = False
self.torqueState = False
self.torqueWindow.setChecked(False)
self.central_widget.setCurrentWidget(self.Visualization)
self.send_sequenceSim.emit(1)
self.central_widget.removeWidget(self.dockSequenceItem)
self.dockSequence.setWidget(self.dockSequenceItem)
self.dockSequence.show()
QMessageBox.about(self, "Succes", "Online mode disable")
except:
QMessageBox.about(self, "Warning", "Somethong it's wrong")
def torqueWindowDef(self, state):
if state:
if (self.online == True):
try:
torque(True)
self.torqueState = True
self.presAngle = getPoseInit()
self.xyz = forward(self.presAngle, self.dataListActual)
self.send_control_init.emit(self.xyz, self.presAngle[3])
self.send_data_result.emit(self.xyz, self.presAngle[3],
self.presAngle)
self.send_plotXYZtheta.emit(self.xyz, self.presAngle)
QMessageBox.about(self, "Succes", "Motor torque enable")
except:
QMessageBox.about(self, "Warning", "Connect motors")
self.torqueWindow.setChecked(False)
else:
self.torqueWindow.setChecked(False)
QMessageBox.about(self, "Warning", "Go online first")
else:
try:
torque(False)
self.torqueState = False
QMessageBox.about(self, "Succes", "Motor torque disable")
except:
QMessageBox.about(self, "Warning", "Somethong it's wrong")
self.torqueWindow.setChecked(False)
def dockWidget(self):
self.central_widget = QStackedWidget()
self.setCentralWidget(self.central_widget)
self.infoText = QLabel("Value out of range")
self.infoText.setStyleSheet(
'color: black; background-color: rgb(255, 255, 255);')
self.infoText.setAlignment(QtCore.Qt.AlignCenter
| QtCore.Qt.AlignVCenter)
self.central_widget.addWidget(self.infoText)
self.Visualization = Plot(self)
self.central_widget.addWidget(self.Visualization)
self.central_widget.setCurrentWidget(self.Visualization)
self.dockConstruct = QDockWidget("Construct", self)
self.dockControl = QDockWidget("Control", self)
self.dockDataResult = QDockWidget("Result", self)
self.dockSequenceTool = QDockWidget("Tool", self)
self.dockSequence = QDockWidget("Sequence", self)
self.dockDataResult.setMaximumHeight(35)
self.dockSequence.setMaximumHeight(62)
self.dockConstruct.setFeatures(QDockWidget.DockWidgetMovable)
self.dockControl.setFeatures(QDockWidget.DockWidgetMovable)
self.dockDataResult.setFeatures(QDockWidget.DockWidgetMovable)
self.dockSequenceTool.setFeatures(QDockWidget.DockWidgetMovable)
self.dockSequence.setFeatures(QDockWidget.DockWidgetMovable)
self.dockConstructItem = construct_class(self)
self.dockControlItem = controll_class(self)
self.dockDataResultItem = dataResult_class(self)
self.dockSequenceToolItem = sequenceTool_class(self)
self.dockSequenceItem = sequence_class(self)
self.dockConstruct.setWidget(self.dockConstructItem)
self.dockControl.setWidget(self.dockControlItem)
self.dockDataResult.setWidget(self.dockDataResultItem)
self.dockSequenceTool.setWidget(self.dockSequenceToolItem)
self.dockSequence.setWidget(self.dockSequenceItem)
self.dockDataResult.setTitleBarWidget(QWidget(None))
self.dockSequence.setTitleBarWidget(QWidget(None))
self.addDockWidget(Qt.RightDockWidgetArea, self.dockConstruct)
self.addDockWidget(Qt.RightDockWidgetArea, self.dockControl)
self.addDockWidget(Qt.BottomDockWidgetArea, self.dockDataResult)
self.addDockWidget(Qt.LeftDockWidgetArea, self.dockSequenceTool)
self.addDockWidget(Qt.TopDockWidgetArea, self.dockSequence)
self.tabifyDockWidget(self.dockConstruct, self.dockControl)
self.dockControlItem.dataControl.connect(self.send_xyz_return)
self.dockConstructItem.send_construct.connect(
self.send_construct_return)
self.dockSequenceToolItem.send_sequenceTool.connect(
self.sequenceTool_return)
self.dockSequenceToolItem.send_sequenceToolStart.connect(
self.sequenceToolStart)
self.dockSequenceToolItem.send_sequenceToolStop.connect(
self.sequenceToolStop)
self.dockSequenceToolItem.send_sequenceToolSave.connect(
self.sequenceToolSave)
self.dockSequenceItem.send_sequence.connect(self.sequence)
self.setLayout(self.mainLayout)
def sequenceToolSave(self, data):
self.sequenceData = data
def sequenceTool_return(self, delay):
self.sequenceList[0] = self.xyz[0]
self.sequenceList[1] = self.xyz[1]
self.sequenceList[2] = self.xyz[2]
self.sequenceList[3] = self.alpha
self.sequenceList[4] = delay
self.send_sequenceActual.emit(self.sequenceList)
def dynamixelFinish(self, finish):
if self.sequenceStatus == 1 and self.online == True and self.torqueState == True:
if self.sequenceCount < len(self.sequenceData):
self.xyz[0] = self.sequenceData[self.sequenceCount][0]
self.xyz[1] = self.sequenceData[self.sequenceCount][1]
self.xyz[2] = self.sequenceData[self.sequenceCount][2]
self.alpha = self.sequenceData[self.sequenceCount][3]
self.send_xyz_return(self.xyz, self.alpha, self.speed)
self.send_sequenceSetAct.emit(self.sequenceCount)
self.sequenceCount += 1
elif self.sequenceStatus == 1 and (self.online == False
or self.torqueState == False):
self.send_sequenceSetAct.emit(self.sequenceCount - 1)
if self.sequenceCount < len(self.sequenceData):
self.xyz[0] = self.sequenceData[self.sequenceCount][0]
self.xyz[1] = self.sequenceData[self.sequenceCount][1]
self.xyz[2] = self.sequenceData[self.sequenceCount][2]
self.alpha = self.sequenceData[self.sequenceCount][3]
self.send_xyz_return(self.xyz, self.alpha, self.speed)
self.sequenceCount += 1
def sequenceToolStop(self, stop):
self.sequenceStatus = 0
self.sequenceCount = 0
def sequenceToolStart(self, speed, data):
try:
self.speed = speed
self.sequenceData = data
self.send_sequenceSetAct.emit(0)
self.sequenceStatus = 1
self.sequenceCount = 1
self.xyz[0] = self.sequenceData[0][0]
self.xyz[1] = self.sequenceData[0][1]
self.xyz[2] = self.sequenceData[0][2]
self.alpha = self.sequenceData[0][3]
self.send_xyz_return(self.xyz, self.alpha, self.speed)
except:
QMessageBox.about(self, "Error", "Add points")
def sequence(self, data):
self.xyz[0] = data[0]
self.xyz[1] = data[1]
self.xyz[2] = data[2]
self.alpha = data[3]
self.send_xyz_return(self.xyz, self.alpha, self.speed)
def send_construct_return(self, select_ret, dataListRet):
self.select, self.dataList, self.dataListActual = select_ret, dataListRet, []
for i in range(len(self.dataList)):
self.dataListActual.append(i)
self.dataListActual[i] = self.dataList[i][self.select]
inverse(self.xyz, self.dataListActual)
self.send_data_result.emit(self.xyz, self.alpha, self.theta)
self.send_plotConst.emit(self.dataListActual)
self.send_plotXYZtheta.emit(self.xyz, self.theta)
def send_xyz_return(self, xyz_ret, alpha, speed):
self.xyz = xyz_ret
self.speed = speed
self.alpha = alpha
self.status, self.theta = inverse(self.xyz, self.dataListActual)
p1 = np.array([0, 0, 0])
p2 = np.array([self.xyz[0], self.xyz[1], self.xyz[2]])
squared_dist = np.sum(p1**2 + p2**2, axis=0)
dist = np.sqrt(squared_dist)
if self.status == 1 or self.alpha < -150 or self.alpha > 150 or (
self.kardanStatus == 1 and
(dist < -self.kardan_max or dist > -self.kardan_min)):
self.central_widget.setCurrentWidget(self.infoText)
else:
dataDynamixel = [
self.theta[0], self.theta[1], self.theta[2], self.alpha
]
if (self.online == True and self.torqueState == True):
self.central_widget.setCurrentWidget(self.dockSequenceItem)
self.send_thread.emit(speed, dataDynamixel)
self.sym = 0
elif (self.sym == 0):
QMessageBox.about(
self, "Warning",
"Simulation mode, to exit enable online mode and motor torque"
)
self.central_widget.setCurrentWidget(self.Visualization)
self.sym = 1
else:
self.send_thread2.emit(speed, self.xyz, self.theta)
self.central_widget.setCurrentWidget(self.Visualization)
if self.sequenceStatus == 0:
self.send_data_result.emit(self.xyz, self.alpha,
self.theta)
def closeEvent(self, event):
settings = QSettings('construct')
settings.setValue('select1', self.select)
for i in range(len(self.dataList)):
settings.setValue('list' + str(i), self.dataList[i])
sequenceListSave = QSettings('SequenceList')
sequenceListSave.setValue('select2', self.sequenceData)
QMainWindow.closeEvent(self, event)
if (self.torqueState == True):
torque(0)
class MainPage(QMainWindow):
engine = create_engine('sqlite:///database.db')
session = sessionmaker()
session.configure(bind=engine)
database.Base.metadata.create_all(engine)
s = session()
def __init__(self):
super(MainPage, self).__init__()
self.ui = Ui_Form()
self.ui.setupUi(self)
self.drm = True
self.ui.cmb_room.addItem("Seçiniz")
self.ui.cmb_room.addItems([str(i) for i in range(1, 21)])
self.ui.table_customer.setHorizontalHeaderLabels(('TC', 'Adı', 'Soyadı', 'Oda No'))
self.ui.table_customer.setColumnCount(4)
self.set_controller()
self.ui.table_customer.insertRow(0)
self.ui.btn_check_in.clicked.connect(self.check_in)
self.ui.btn_check_out.clicked.connect(self.check_out)
self.ui.btn_add_person.clicked.connect(self.add_person)
self.ui.check_out_date.dateChanged.connect(self.calculate_fee)
self.th = Thread()
self.th.changePixmap.connect(self.set_image)
self.th.start()
def calculate_fee(self):
start_date = self.ui.check_in_date.date()
end_date = self.ui.check_out_date.date()
days = start_date.daysTo(end_date)
self.ui.txt_fee.setText(str(days * 100) + "TL")
@pyqtSlot(QImage)
def set_image(self, image):
self.ui.lbl_camera.setPixmap(QPixmap.fromImage(image))
def add_person(self):
try:
resized_image = cv2.resize(self.th.take_photo(), (640, 480))
cv2.imwrite('id.jpg', resized_image)
img = Image.open('id.jpg')
text = pytesseract.image_to_string(img)
big_data = text.split("<")
name = ""
surname = ""
tc_no = ""
for i in big_data:
if i.isalnum() and len(i) == 11:
tc_no = i
elif i.isalpha() and len(i) > 1:
if name == "":
name = i
surname = big_data[big_data.index(name) - 2]
else:
name += " " + i
surname = surname[surname.index("\n") + 1:]
msg = QMessageBox()
msg.setWindowTitle('Kimlik Verileri')
msg.setText('Kimlik Bilgileri\nTC :' + tc_no + '\nAdı Soyadı :' + name + " " + surname)
msg.setIcon(QMessageBox.Question)
msg.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel)
x = msg.exec_()
if x == 1024:
self.ui.table_customer.setItem(0, 0, QTableWidgetItem(tc_no))
self.ui.table_customer.setItem(0, 1, QTableWidgetItem(name))
self.ui.table_customer.setItem(0, 2, QTableWidgetItem(surname))
self.ui.btn_add_person.setEnabled(False)
data = self.s.query(MusteriListesi).filter(MusteriListesi.tc_no == tc_no).first()
if data:
self.ui.table_customer.setItem(0, 3, QTableWidgetItem(data.oda_no.oda_no))
self.ui.btn_check_out.setEnabled(True)
else:
self.ui.check_in_date.setEnabled(True)
self.ui.check_out_date.setEnabled(True)
self.ui.cmb_room.setEnabled(True)
self.ui.txt_fee.setEnabled(True)
self.ui.btn_check_in.setEnabled(True)
except Exception:
msg = QMessageBox()
msg.setWindowTitle('Okuma Hatası')
msg.setText('Kimlik bilgileri okunamadı!\nLütfen yeniden deneyin.')
msg.setIcon(QMessageBox.Warning)
msg.setStandardButtons(QMessageBox.Ok)
msg.exec_()
def check_in(self):
check_detail = GirisCikis(giris_tarihi=self.ui.check_in_date.text(),
cikis_tarihi=self.ui.check_out_date.text(),
oda_no=self.ui.cmb_room.currentText(),
fiyat=self.ui.txt_fee.text())
customer = MusteriListesi(tc_no=self.ui.table_customer.item(0, 0).text(),
adi=self.ui.table_customer.item(0, 1).text(),
soyadi=self.ui.table_customer.item(0, 2).text(),
oda_no=check_detail)
self.s.add(check_detail)
self.s.add(customer)
self.s.commit()
msg = QMessageBox()
msg.setWindowTitle('Kaydetme İşlemi')
msg.setText('Kayıt başarı ile tamamlandı.')
msg.setIcon(QMessageBox.Warning)
msg.setStandardButtons(QMessageBox.Ok)
msg.exec_()
self.set_controller()
def check_out(self):
tc_no = self.ui.table_customer.item(0, 0).text()
data = self.s.query(MusteriListesi).filter(MusteriListesi.tc_no == tc_no).first()
self.s.query(MusteriListesi).filter(MusteriListesi.tc_no == self.ui.table_customer.item(0, 0).text()).delete()
self.s.query(GirisCikis).filter(GirisCikis.id == data.musteri_id).delete()
self.s.commit()
msg = QMessageBox()
msg.setWindowTitle('Silme İşlemi')
msg.setText('Kayıt başarı ile silindi.')
msg.setIcon(QMessageBox.Warning)
msg.setStandardButtons(QMessageBox.Ok)
msg.exec_()
self.set_controller()
def set_controller(self):
date = datetime.now()
self.ui.check_in_date.setDate(QDate(date.year, date.month, date.day))
self.ui.check_out_date.setDate(QDate(date.year, date.month, date.day))
self.ui.cmb_room.setCurrentIndex(0)
self.ui.txt_fee.setText("0TL")
self.ui.table_customer.clear()
self.ui.table_customer.setHorizontalHeaderLabels(('TC', 'Adı', 'Soyadı', 'Oda No'))
self.ui.check_in_date.setEnabled(False)
self.ui.check_out_date.setEnabled(False)
self.ui.cmb_room.setEnabled(False)
self.ui.txt_fee.setEnabled(False)
self.ui.btn_check_in.setEnabled(False)
self.ui.btn_check_out.setEnabled(False)
self.ui.btn_add_person.setEnabled(True)
class MainWindow(QtWidgets.QMainWindow, design.Ui_MainWindow):
"""App main window"""
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.config = None
self.config_file_path = os.path.join(
os.path.split(os.path.abspath(__file__))[0], 'config.json')
icon = QtGui.QIcon()
cog_file_path = os.path.join(
os.path.split(os.path.abspath(__file__))[0], 'cog.png')
icon.addPixmap(QtGui.QPixmap(cog_file_path), QtGui.QIcon.Normal,
QtGui.QIcon.Off)
self.setWindowIcon(icon)
self.setupUi(self)
self.report = None
self.btn_start.disconnect()
self.btn_start.clicked.connect(self.create_subtasks)
self.actionCredenciais_JIRA.disconnect()
self.actionCredenciais_JIRA.triggered.connect(self.show_configcred)
self.actionLimpar_Log.disconnect()
self.actionLimpar_Log.triggered.connect(self.log_entries.clear)
self._load_configuration()
self.thread = None
self.config_window = ConfigWindow(self)
self.project_key_text.textChanged.connect(self._update_config)
self.project_key_text.setHtml(self.config['project_key'].strip())
self._update_config()
def _update_config(self):
self.config['jira_user'] = str(
self.config_window.jira_email_text.toPlainText()).strip()
self.config['jira_token'] = str(
self.config_window.jira_token_text.toPlainText()).strip()
self.config['jira_base_url'] = str(
self.config_window.jira_url_text.toPlainText()).strip()
self.config['project_key'] = str(
self.project_key_text.toPlainText()).strip()
self.save_configuration()
def _load_configuration(self):
if os.path.isfile(self.config_file_path):
with open(self.config_file_path) as config_file:
self.config = json.load(config_file)
else:
self.save_configuration()
def _check_config(self):
return (self.config["jira_base_url"] and self.config["jira_token"]
and self.config["jira_user"])
def save_configuration(self):
"""saves/creates the configuration file"""
if not os.path.isfile(self.config_file_path):
if not os.path.isfile(
os.path.join(
os.path.split(os.path.abspath(__file__))[0],
'config.template.json')):
self.config = {
"jira_base_url": "https://helpdeskmobly.atlassian.net",
"jira_token": "",
"jira_user": "",
"project_key": ""
}
else:
with open(
os.path.join(
os.path.split(os.path.abspath(__file__))[0],
'config.template.json')) as template_config_file:
self.config = json.load(template_config_file)
with open(self.config_file_path, 'w') as config_file:
json.dump(self.config,
config_file,
sort_keys=True,
indent=4)
with open(self.config_file_path, 'w') as config_file:
json.dump(self.config, config_file, sort_keys=True, indent=4)
def show_configcred(self):
"""pops up the configuration window"""
self.config_window.show()
def add_log_post(self, log_data):
"""logs message to the board"""
self.log_entries.append(log_data)
self.log_entries.moveCursor(QtGui.QTextCursor.End)
def set_progress_bar(self, value, total):
"""updates progress bar to value"""
self.progress_bar.setValue(value)
self.progress_bar.setMaximum(total)
def create_subtasks(self):
"""Get the data from the table and create each subtask (DEV and QA)"""
if not self._check_config():
self.add_log_post("Verifique suas configurações (CTRL+J)")
return
self.progress_bar.setValue(0)
self.log_entries.clear()
if self.thread is not None and self.thread.isRunning():
self.thread.stop()
self.thread = None
return
task_list = list()
raw_html = self.stories_data.toHtml()
html_data = BeautifulSoup(raw_html, features='lxml')
for line_break in html_data.find_all("br"):
line_break.replace_with("\n")
for row in html_data.findAll('tr'):
cell = row.findAll('td')
if len(cell) == 5:
task = {
"parent":
cell[0].text.strip('\n'),
"title":
cell[1].text.strip('\n').replace("\n", " "),
"desc":
cell[2].text.strip('\n'),
"devpts":
float(cell[3].text.strip('\n') or 0),
"qapts":
float(cell[4].text.strip('\n'))
if cell[4].text.strip('\n') else ""
}
task_list.append(task)
else:
self.add_log_post(
"dá uma olhada na sua tabela, todas as linhas tem que ter 5 colunas: \
\n| Parent Story | Title | Description | DEV Points | QA Points |"
)
self.thread = Thread(task_list, self.config)
self.thread.add_log_post.connect(self.add_log_post)
self.thread.set_progress_bar.connect(self.set_progress_bar)
self.thread.finished.connect(self.done)
self.btn_stop.setEnabled(True)
self.btn_stop.disconnect()
self.btn_stop.clicked.connect(self.done)
self.btn_start.setEnabled(False)
self.thread.start()
def done(self):
"""Controls UI when thread is done and kills eventual remaining threads"""
if self.thread is not None and self.thread.isRunning():
self.thread.stop()
self.thread = None
self.btn_stop.setEnabled(False)
self.btn_start.setEnabled(True)
self.progress_bar.setValue(0)
self.add_log_post("Processos e conexões terminadas.")
class Ntp:
"""
A service for synchronizing the local clock with an NTP service once a day.
If the NTP service is unavailable, this service will retry synchronization
every hour.
"""
def __init__(self, wifi: Wifi, oled):
self.wifi = wifi
self.oled = oled
self.thread = Thread(self.__run, "NtpThread")
def start(self):
self.thread.start()
def __run(self, thread: Thread):
while thread.active:
self.wifi.acquire()
try:
if self.wifi.connect():
utime.sleep(5) # Sometimes it fails if we are too fast
self.__settime()
print("Updated clock with NTP")
self.oled.push_line("Updated clock")
continue
except IndexError:
print("Failed to update clock")
pass
finally:
self.wifi.release()
self.wifi.deactivate(False)
utime.sleep(60 * 60 * 24)
# Retry in an hour
utime.sleep(60 * 60)
def __time(self):
ntp_query = bytearray(48)
ntp_query[0] = 0x1B
addr = socket.getaddrinfo(HOST, 123)[0][-1]
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
try:
for _ in range(5):
try:
s.settimeout(1)
_ = s.sendto(ntp_query, addr)
msg = s.recv(48)
break
except OSError:
pass
finally:
s.close()
val = struct.unpack("!I", msg[40:44])[0]
return val - NTP_DELTA
def __settime(self):
t = utime.localtime(self.__time())
machine.RTC().init((t[0], t[1], t[2], 0, t[3] + 1, t[4], t[5], t[6]))
