class TopCitiesController:
def __init__(self, recv_queue, send_queue, total_workers, status_queue,
data_cluster_write, data_cluster_read):
self.protocol = Protocol(recv_queue, send_queue, total_workers,
status_queue, data_cluster_write,
data_cluster_read)
self.cities_data = {}
def start(self):
self.protocol.start_connection(self.data_read, self.process_results,
self.load_data, self.reset_data,
self.save_data)
def data_read(self, cities_data):
self.cities_data.update(cities_data)
def process_results(self):
top_cities = dict(Counter(self.cities_data).most_common(3))
self.protocol.send_data(top_cities)
def load_data(self, cities_data):
self.cities_data = cities_data
def reset_data(self):
self.cities_data = {}
def save_data(self):
return self.cities_data
def __init__(self, recv_queue, send_queue, total_workers, status_queue,
data_cluster_write, data_cluster_read):
self.protocol = Protocol(recv_queue, send_queue, total_workers,
status_queue, data_cluster_write,
data_cluster_read)
self.cities_data = {}
class MasterController:
def __init__(self, recv_queue, send_queue, total_workers):
self.protocol = Protocol(recv_queue, send_queue, total_workers)
def start(self):
#self.protocol.start_connection(self.data_read)
self.protocol.start_connection()
class DateSorter:
def __init__(self, recv_queue, send_queue, total_workers, status_queue,
data_cluster_write, data_cluster_read):
self.protocol = Protocol(recv_queue, send_queue, total_workers,
status_queue, data_cluster_write,
data_cluster_read)
self.date_data = OrderedDict()
def start(self):
self.protocol.start_connection(self.data_read, self.process_results,
self.load_data, self.reset_data,
self.save_data)
def data_read(self, data):
self.date_data.update(sorted(data.items()))
def process_results(self):
self.protocol.send_data(self.date_data)
def load_data(self, date_data):
self.date_data = date_data
def reset_data(self):
self.date_data = OrderedDict()
def save_data(self):
return self.date_data
class Worker:
def __init__(self, recv_queue, send_queue, status_queue,
data_cluster_write, data_cluster_read):
self.protocol = Protocol(recv_queue, send_queue, status_queue,
data_cluster_write, data_cluster_read)
self.results_per_date = {}
def start(self):
self.protocol.start_connection(self.data_read, self.process_results,
self.load_data, self.reset_data,
self.save_data)
def data_read(self, date, result):
if date not in self.results_per_date:
self.results_per_date[date] = [0, 0]
if result == "positivi":
self.results_per_date[date][0] += 1
else:
self.results_per_date[date][1] += 1
def process_results(self):
self.protocol.send_data(self.results_per_date)
def load_data(self, date_results):
self.results_per_date = date_results
def reset_data(self):
self.results_per_date = {}
def save_data(self):
return self.results_per_date
def __init__(self, recv_queue, send_queue, total_workers, status_queue,
data_cluster_write, data_cluster_read):
self.protocol = Protocol(recv_queue, send_queue, total_workers,
status_queue, data_cluster_write,
data_cluster_read)
self.date_data = OrderedDict()
class Worker:
def __init__(self, recv_queue, send_queue, status_queue,
data_cluster_write, data_cluster_read):
self.protocol = Protocol(recv_queue, send_queue, status_queue,
data_cluster_write, data_cluster_read)
self.positives_per_city = {}
def start(self):
self.protocol.start_connection(self.data_read, self.process_results,
self.load_data, self.reset_data,
self.save_data)
def data_read(self, place):
if place not in self.positives_per_city:
self.positives_per_city[place] = 0
self.positives_per_city[place] += 1
print("Positive of {}".format(place))
def load_data(self, positives_per_city):
self.positives_per_city = positives_per_city
def reset_data(self):
self.positives_per_city = {}
def save_data(self):
return self.positives_per_city
def process_results(self):
self.protocol.send_data(self.positives_per_city)
def __init__(self, recv_queue, status_queue, data_cluster_write,
data_cluster_read, coordinator_queue):
self.protocol = Protocol(recv_queue, status_queue, data_cluster_write,
data_cluster_read, coordinator_queue)
self.top_cities = None
self.date_data = None
self.percentage = None
def __init__(self, recv_queue, send_queues, data_cluster_write,
data_cluster_read, place_manager_queue):
self.state_saver = StateSaver(STAGE, data_cluster_write,
data_cluster_read)
self.protocol = Protocol(recv_queue, send_queues, self.state_saver,
place_manager_queue)
self.working = False
self.actual_conn = None
class SummaryController:
def __init__(self, recv_queue, status_queue, data_cluster_write,
data_cluster_read, coordinator_queue):
self.protocol = Protocol(recv_queue, status_queue, data_cluster_write,
data_cluster_read, coordinator_queue)
self.top_cities = None
self.date_data = None
self.percentage = None
def start(self):
self.protocol.start_connection(self.top_cities_read,
self.date_data_read, self.count_read,
self.write_summary, self.load_data,
self.reset_data, self.save_data)
def top_cities_read(self, top_cities):
self.top_cities = top_cities
def date_data_read(self, date_data):
self.date_data = date_data
def count_read(self, percentage):
if percentage.isdigit():
self.percentage = float(percentage) * 100
else:
self.percentage = percentage
def write_summary(self, conn_id):
print("Starting to write file {}".format(FOLDER_WRITE + 'summary_' +
conn_id + '.txt'))
with open(FOLDER_WRITE + 'summary_' + conn_id + '.txt', 'w') as file:
file.write("date - totale_positivi - totale_deceduti\n")
for date in self.date_data:
file.write(date + " - " + str(self.date_data[date][0]) +
" - " + str(self.date_data[date][1]) + "\n")
file.write("\nTop 3 cities - totale positivi\n")
for place in self.top_cities:
file.write(place + " - " + str(self.top_cities[place]) + "\n")
file.write("\nPorcentuale Deceduti=")
file.write(str(self.percentage) + "%")
def load_data(self, data):
self.top_cities = data[0]
self.date_data = data[1]
self.percentage = data[2]
def reset_data(self):
self.top_cities = None
self.date_data = None
self.percentage = None
def save_data(self):
return [self.top_cities, self.date_data, self.percentage]
def servo_process(cmd_queue):
from protocol.protocol import Protocol
protocol = Protocol('com4')
while 1:
cmd = cmd_queue.get()
if cmd is None:
break
group, servo, value = cmd
protocol.move_servo(group, servo, value)
def __init__(self, recv_queue, send_queue, status_queue, data_cluster_write, data_cluster_read):
self.protocol = Protocol(
recv_queue,
send_queue,
status_queue,
data_cluster_write,
data_cluster_read
)
self.total_positivi = 0
self.total_deceduti = 0
class DateSorter:
def __init__(self, recv_queue, send_queue, total_workers):
self.protocol = Protocol(recv_queue, send_queue, total_workers)
self.date_data = OrderedDict()
def start(self):
self.protocol.start_connection(self.data_read)
self.process_results()
def data_read(self, data):
self.date_data.update(sorted(data.items()))
def process_results(self):
self.protocol.send_data(self.date_data)
class SummaryController:
def __init__(self, recv_queue):
self.protocol = Protocol(recv_queue)
def start(self):
self.protocol.start_connection(
self.top_cities_read,
self.date_data_read,
self.count_read
)
self.write_summary()
def top_cities_read(self, top_cities):
self.top_cities = top_cities
def date_data_read(self, date_data):
self.date_data = date_data
def count_read(self, percentage):
self.percentage = percentage * 100
def write_summary(self):
with open(WRITE_FILE, 'w') as file:
file.write("date - totale_positivi - totale_deceduti\n")
for date in self.date_data:
file.write(
date +
" - " +
str(self.date_data[date][0]) +
" - " +
str(self.date_data[date][1]) +
"\n"
)
file.write("\nTop 3 cities - totale positivi\n")
for place in self.top_cities:
file.write(
place +
" - " +
str(self.top_cities[place]) +
"\n"
)
file.write("\nPorcentuale Deceduti=")
file.write(str(self.percentage) + "%")
class TopCitiesController:
def __init__(self, recv_queue, send_queue, total_workers):
self.protocol = Protocol(recv_queue, send_queue, total_workers)
self.cities_data = {}
self.top_cities = {}
def start(self):
self.protocol.start_connection(self.data_read)
self.process_results()
def data_read(self, data):
self.cities_data.update(data)
def process_results(self):
self.top_cities = dict(Counter(self.cities_data).most_common(3))
self.protocol.send_data(self.top_cities)
class Worker:
def __init__(self, recv_queue, send_queue, master_queue):
self.protocol = Protocol(recv_queue, send_queue, master_queue)
self.positives_per_city = {}
def start(self):
self.protocol.start_connection(self.data_read)
self.process_results()
def data_read(self, place):
if place not in self.positives_per_city:
self.positives_per_city[place] = 0
self.positives_per_city[place] += 1
def process_results(self):
self.protocol.send_data(self.positives_per_city)
class Worker:
def __init__(self, recv_queue, send_queue, status_queue, data_cluster_write, data_cluster_read):
self.protocol = Protocol(
recv_queue,
send_queue,
status_queue,
data_cluster_write,
data_cluster_read
)
self.total_positivi = 0
self.total_deceduti = 0
def start(self):
self.protocol.start_connection(
self.data_read,
self.process_results,
self.load_data,
self.reset_data,
self.save_data
)
def data_read(self, positivi, deceduti):
self.total_positivi += int(positivi)
self.total_deceduti += int(deceduti)
def process_results(self):
result = "Not possible"
if self.total_positivi != 0:
result = str(self.total_deceduti / self.total_positivi)
self.protocol.send_data(result)
def load_data(self, data):
self.total_positivi = data[0]
self.total_deceduti = data[1]
def reset_data(self):
self.total_positivi = 0
self.total_deceduti = 0
def save_data(self):
return [self.total_positivi, self.total_deceduti]
class CoordinatorManager:
def __init__(self, recv_queue, send_queues, data_cluster_write,
data_cluster_read, place_manager_queue):
self.state_saver = StateSaver(STAGE, data_cluster_write,
data_cluster_read)
self.protocol = Protocol(recv_queue, send_queues, self.state_saver,
place_manager_queue)
self.working = False
self.actual_conn = None
def start(self):
load = self.state_saver.load_state("STATE")
if load != None:
[conn_id, state] = json.loads(load)
self.actual_conn = conn_id
if state == "RESTART":
self.work_finished(conn_id)
elif state == "BLOCKED":
self.working = True
self.protocol.start_receiving(self.work_finished, self.new_client)
def new_client(self, conn_id):
if conn_id == self.actual_conn:
return READY
if self.working:
return NOT_READY
self.working = True
self.actual_conn = conn_id
return READY
def work_finished(self, conn_id):
#Force place manager to restart its requester
#and force every worker to restart
self.protocol.restart_all_senders(conn_id)
self.working = False
class Worker:
def __init__(self, recv_queue, send_queue):
self.protocol = Protocol(recv_queue, send_queue)
self.total_positivi = 0
self.total_deceduti = 0
def start(self):
self.protocol.start_connection(self.data_read)
self.process_results()
def data_read(self, positivi, deceduti):
self.total_positivi += positivi
self.total_deceduti += deceduti
def process_results(self):
result = self.total_deceduti / self.total_positivi
self.protocol.send_data(result)
class PingPongManager:
def __init__(self, xbee: XBee):
self._xbee = xbee
self._protocol = Protocol(xbee)
self._protocol.on_packet(PingPongPacket, self.on_message_received)
self._time = time.time()
async def init(self):
logging.info('init')
address = await self._xbee.discover_first_remote_device()
logging.info('address\t')
self._protocol.send_packet(
address, PingPongPacket(index=0, payload=generate_payload(0)))
def on_message_received(self, remote_address: bytearray,
ping_pong: PingPongPacket):
t = time.time()
delta = t - self._time
self._time = t
logging.info("Received (%s) \t%s\t%d", delta, remote_address,
ping_pong.index)
ping_pong.index += 1
ping_pong.payload = generate_payload(ping_pong.index)
try:
self._protocol.send_packet(remote_address, ping_pong)
logging.info("Send\t%s\t%d", remote_address, ping_pong.index)
except Exception as e:
logging.error("Send error\t%s\t%s", remote_address, e)
async def main():
parser = ArgumentParser()
parser.add_argument('--device', required=True)
parser.add_argument('--db-uri', required=False)
parser.add_argument('--timeout', type=float, default=30)
use_stubs = bool(os.environ.get('USE_STUBS', False))
args = parser.parse_args()
if not use_stubs:
xbee = XBee(args.device)
xbee.open()
protocol = Protocol(xbee, args.timeout)
protocol.on_packet(CurrentLocationPacket, gps_data_received)
protocol.on_request(SignDataRequest, sign_data_handler)
if args.db_uri:
database = Database(args.db_uri)
set_interval(sign_data_task, 1, protocol, database)
set_interval(send_gps_task, 1, protocol, database)
else:
if args.db_uri:
database = Database(args.db_uri)
set_interval(sign_data_task, 1, None, database)
class Worker:
def __init__(self, recv_queue, send_queue, master_queue):
self.protocol = Protocol(recv_queue, send_queue, master_queue)
self.results_per_date = {}
def start(self):
self.protocol.start_connection(self.data_read)
self.process_results()
def data_read(self, date, result):
if date not in self.results_per_date:
self.results_per_date[date] = [0, 0]
if result == "positivi":
self.results_per_date[date][0] += 1
else:
self.results_per_date[date][1] += 1
def process_results(self):
self.protocol.send_data(self.results_per_date)
def __init__(self, parent=None):
super(QtGui.QWidget, self).__init__(parent)
uic.loadUi("main_window.ui", self)
self.protocol = Protocol(port_name="com6", baudrate=115200)
self.config = json.loads(open("config.json", "rb").read())
self.played = False
self.timer = QtCore.QTimer()
self.timer.setSingleShot(False)
self.timer.setInterval(2)
self.timer.timeout.connect(self.onTimeout)
self.settings = QtCore.QSettings("AlexLexx", "servo_animator")
self.spinBox_max_time.setValue(10.0);
self.doubleSpinBox_speed.setValue(1.0);
self.checkBox_load_last_anamation.setChecked(self.settings.value("load_last_anamation", True).toPyObject())
self.checkBox_enable_servo.setChecked(self.settings.value("enable_servo", False).toPyObject())
self.checkBox_enable_auto_save.setChecked(self.settings.value("enable_auto_save", False).toPyObject())
#создадим сервы
self.groups = []
for index, conf in enumerate(self.config["groups"]):
frame = frames.GroupFrame(self)
frame.load_config(conf, index)
self.tab.addTab(frame, conf["name"])
frame.servo_value_changed_signal.connect(self.on_servo_value_changed_signal)
frame.range_value_changed_signal.connect(self.on_range_value_changed_signal)
frame.resolution_changed_signal.connect(self.on_resolution_changed_signal)
frame.period_changed_signal.connect(self.on_period_changed_signal)
frame.setup_signal.connect(self.on_setup_ranges)
frame.load_signal.connect(self.on_load_ranges)
self.groups.append(frame)
self.time_window_pos = 0.0
self.time_window_size = self.spinBox_max_time.value()
self.listWidget.addAction(self.action_remove)
self.listWidget.addAction(self.action_create)
self.listWidget.addAction(self.action_copy)
self.listWidget.addAction(self.action_insert)
self.copied_data = None
if self.checkBox_load_last_anamation.isChecked():
file_name = self.settings.value("last_animation_file", "").toPyObject()
if file_name != "":
self.load_from_file(file_name)
class ChunkManager:
def __init__(self, queue_map, queue_date, queue_count, eof_map, eof_date,
eof_count, topic_places):
self.protocol = Protocol(queue_map, queue_date, queue_count, eof_map,
eof_date, eof_count, topic_places)
def process_places(self, route):
with open(route) as csv_file:
csv_reader = csv.reader(csv_file, delimiter=',')
line_count = 0
for row in csv_reader:
if line_count == 0:
line_count += 1
continue
else:
region = row[0]
latitude = row[1]
longitude = row[2]
line_count += 1
self.protocol.process_places(region, latitude, longitude)
print("All places were sent")
self.protocol.send_no_more_places()
def process_data(self, route):
with open(route) as csv_file:
csv_reader = csv.reader(csv_file, delimiter=',')
line_count = 0
for row in csv_reader:
if line_count == 0:
line_count += 1
continue
else:
date = row[0]
latitude = row[1]
longitude = row[2]
result = row[3]
line_count += 1
self.protocol.process(date, latitude, longitude, result)
self.protocol.close()
def __init__(self, recv_queue, send_queue, total_workers):
self.protocol = Protocol(recv_queue, send_queue, total_workers)
def __init__(self, recv_queue, send_queue, status_queue,
data_cluster_write, data_cluster_read):
self.protocol = Protocol(recv_queue, send_queue, status_queue,
data_cluster_write, data_cluster_read)
self.results_per_date = {}
class USBDriver(AbstractDriver):
def __init__(self, device_map, options):
self._serial = None
self._PROTOCOL = Protocol(device_map)
self._OPTIONS = options
def _findDevice(self):
com = None
# TODO: Will fix device finding method.
for DEVICE in list(serial.tools.list_ports.comports()):
if 'Arduino Micro' in DEVICE[1]:
com = DEVICE[0]
return com
def apply(self, device, value):
if self._serial is None:
_LOGGER.error('Serial connection is disabled!')
return False
try:
self._serial.write(self._PROTOCOL.apply(device, int(value)))
time.sleep(0.01)
except (
serial.serialutil.SerialException,
serial.serialutil.SerialTimeoutException
):
_LOGGER.error('USB cable is disconnected!')
self.disconnect()
return False
return True
def applyDiff(self, device, value):
if self._serial is None:
_LOGGER.error('Serial connection is disabled!')
return False
try:
self._serial.write(self._PROTOCOL.applyDiff(device, int(value)))
time.sleep(0.01)
except (
serial.serialutil.SerialException,
serial.serialutil.SerialTimeoutException
):
_LOGGER.error('USB cable is disconnected!')
self.disconnect()
return False
return True
def setHome(self, device, value):
if self._serial is None:
_LOGGER.error('Serial connection is disabled!')
return False
try:
self._serial.write(self._PROTOCOL.setHome(device, int(value)))
time.sleep(0.01)
except (
serial.serialutil.SerialException,
serial.serialutil.SerialTimeoutException
):
_LOGGER.error('USB cable is disconnected!')
self.disconnect()
return False
return True
def play(self, slot):
if self._serial is None:
_LOGGER.error('Serial connection is disabled!')
return False
try:
self._serial.write(self._PROTOCOL.playMotion(slot))
except (
serial.serialutil.SerialException,
serial.serialutil.SerialTimeoutException
):
_LOGGER.error('USB cable is disconnected!')
self.disconnect()
return False
return True
def stop(self):
if self._serial is None:
_LOGGER.error('Serial connection is disabled!')
return False
try:
self._serial.write(self._PROTOCOL.stopMotion())
except (
serial.serialutil.SerialException,
serial.serialutil.SerialTimeoutException
):
_LOGGER.error('USB cable is disconnected!')
self.disconnect()
return False
return True
def push(self, slot, loop_count):
if self._serial is None:
_LOGGER.error('Serial connection is disabled!')
return False
try:
# TODO: Will fix loop_count adjustment.
self._serial.write(self._PROTOCOL.pushCode(int(slot), int(loop_count) + 1))
time.sleep(0.01)
except (
serial.serialutil.SerialException,
serial.serialutil.SerialTimeoutException
):
_LOGGER.error('USB cable is disconnected!')
self.disconnect()
return False
return True
def pop(self):
if self._serial is None:
_LOGGER.error('Serial connection is disabled!')
return False
try:
self._serial.write(self._PROTOCOL.popCode())
time.sleep(0.01)
except (
serial.serialutil.SerialException,
serial.serialutil.SerialTimeoutException
):
_LOGGER.error('USB cable is disconnected!')
self.disconnect()
return False
return True
def install(self, motion):
if self._serial is None:
_LOGGER.error('Serial connection is disabled!')
return False
if not validate(motion):
_LOGGER.error('Motion schema is wrong!')
return False
CMD = self._PROTOCOL.install(motion)
# Divide command length by payload size.
PAYLOAD = 32
BLOCK, SURPLUS = divmod(len(CMD), PAYLOAD)
try:
for INDEX in range(BLOCK):
self._serial.write(CMD[PAYLOAD * INDEX: PAYLOAD * (INDEX + 1)])
time.sleep(0.05)
if SURPLUS:
self._serial.write(CMD[-SURPLUS:])
time.sleep(0.05)
except (
serial.serialutil.SerialException,
serial.serialutil.SerialTimeoutException
):
_LOGGER.error('USB cable is disconnected!')
self.disconnect()
return False
return True
def resetJointSettings(self):
if self._serial is None:
_LOGGER.error('Serial connection is disabled!')
return False
try:
self._serial.write(
self._PROTOCOL.setJointSettings()
+ self._PROTOCOL.homePosition()
)
except (
serial.serialutil.SerialException,
serial.serialutil.SerialTimeoutException
):
_LOGGER.error('USB cable is disconnected!')
self.disconnect()
return False
return True
def getMotion(self, slot):
if self._serial is None:
_LOGGER.error('Serial connection is disabled!')
return None
try:
self._serial.write(self._PROTOCOL.getMotion(slot))
time.sleep(0.1)
except (
serial.serialutil.SerialException,
serial.serialutil.SerialTimeoutException
):
_LOGGER.error('USB cable is disconnected!')
self.disconnect()
return None
motion = ''
while self._serial.in_waiting > 0:
motion += self._serial.read(self._serial.in_waiting)
time.sleep(0.01)
if len(motion):
return json.loads(motion)
return None
def getVersionInformation(self):
if self._serial is None:
_LOGGER.error('Serial connection is disabled!')
return None
try:
self._serial.write(self._PROTOCOL.getVersionInformation())
time.sleep(0.1)
except (
serial.serialutil.SerialException,
serial.serialutil.SerialTimeoutException
):
_LOGGER.error('USB cable is disconnected!')
self.disconnect()
return None
version = ''
while self._serial.in_waiting > 0:
version += self._serial.read(self._serial.in_waiting)
time.sleep(0.01)
if len(version):
return json.loads(version)
return None
def connect(self):
self.disconnect()
COM = self._findDevice()
if COM is None:
_LOGGER.error('PLEN is not found!')
return False
self._serial = serial.Serial(port=COM, baudrate=2000000, timeout=1)
self._serial.reset_input_buffer()
self._serial.reset_output_buffer()
return True
def disconnect(self):
if self._serial is None:
_LOGGER.error('Serial connection is disabled!')
return False
self._serial.close()
self._serial = None
return True
def upload(self, code):
self.disconnect()
COM = self._findDevice()
if COM is None:
_LOGGER.error('PLEN is not found!')
return False
shutil.rmtree('temp', ignore_errors=True)
os.mkdir('temp')
with open('./temp/temp.ino', 'w') as fout:
fout.write(code)
proc = subprocess.Popen(
[
self._OPTIONS['compiler']['path'],
'--port', COM,
'--board', 'arduino:avr:micro',
'--upload', os.path.realpath('./temp/temp.ino')
],
stdout = subprocess.PIPE,
stderr = subprocess.STDOUT
)
proc.wait()
if _OS_TYPE == 'Windows':
return proc.stdout.read().decode('shift-jis').encode('utf-8')
return proc.stdout.read()
def __init__(self, device_map, options):
self._serial = None
self._PROTOCOL = Protocol(device_map)
self._OPTIONS = options
class MainWindow(QtGui.QMainWindow):
CONCRETE = 0
BRICK = 1
def __init__(self, parent=None):
super(QtGui.QWidget, self).__init__(parent)
uic.loadUi("main_window.ui", self)
self.protocol = Protocol(port_name="com6", baudrate=115200)
self.config = json.loads(open("config.json", "rb").read())
self.played = False
self.timer = QtCore.QTimer()
self.timer.setSingleShot(False)
self.timer.setInterval(2)
self.timer.timeout.connect(self.onTimeout)
self.settings = QtCore.QSettings("AlexLexx", "servo_animator")
self.spinBox_max_time.setValue(10.0);
self.doubleSpinBox_speed.setValue(1.0);
self.checkBox_load_last_anamation.setChecked(self.settings.value("load_last_anamation", True).toPyObject())
self.checkBox_enable_servo.setChecked(self.settings.value("enable_servo", False).toPyObject())
self.checkBox_enable_auto_save.setChecked(self.settings.value("enable_auto_save", False).toPyObject())
#создадим сервы
self.groups = []
for index, conf in enumerate(self.config["groups"]):
frame = frames.GroupFrame(self)
frame.load_config(conf, index)
self.tab.addTab(frame, conf["name"])
frame.servo_value_changed_signal.connect(self.on_servo_value_changed_signal)
frame.range_value_changed_signal.connect(self.on_range_value_changed_signal)
frame.resolution_changed_signal.connect(self.on_resolution_changed_signal)
frame.period_changed_signal.connect(self.on_period_changed_signal)
frame.setup_signal.connect(self.on_setup_ranges)
frame.load_signal.connect(self.on_load_ranges)
self.groups.append(frame)
self.time_window_pos = 0.0
self.time_window_size = self.spinBox_max_time.value()
self.listWidget.addAction(self.action_remove)
self.listWidget.addAction(self.action_create)
self.listWidget.addAction(self.action_copy)
self.listWidget.addAction(self.action_insert)
self.copied_data = None
if self.checkBox_load_last_anamation.isChecked():
file_name = self.settings.value("last_animation_file", "").toPyObject()
if file_name != "":
self.load_from_file(file_name)
def on_servo_value_changed_signal(self, group_id, servo_id, value):
if self.checkBox_enable_servo.isChecked():
self.protocol.move_servo(group_id, servo_id, value)
def on_setup_ranges(self, group_id):
if self.checkBox_enable_servo.isChecked():
data = self.groups[group_id].get_ranges_data()
self.protocol.set_group_params(group_id, data[0], data[1], data[2])
def on_load_ranges(self, group_id):
if self.checkBox_enable_servo.isChecked():
self.groups[group_id].set_ranges_data(self.protocol.get_group_params(group_id))
def on_range_value_changed_signal(self, group_id, servo_id, min, max):
self.config["groups"][group_id]["controlls"][servo_id]["min"] = min
self.config["groups"][group_id]["controlls"][servo_id]["max"] = max
if self.checkBox_enable_config_modification.isChecked():
open("config_new.json", "wb").write(json.dumps(self.config, indent=1))
def on_resolution_changed_signal(self, group_id, resolution):
self.config["groups"][group_id]["resolution"] = resolution
if self.checkBox_enable_config_modification.isChecked():
open("config_new.json", "wb").write(json.dumps(self.config, indent=1))
def on_period_changed_signal(self, group_id, period):
self.config["groups"][group_id]["period"] = period
if self.checkBox_enable_config_modification.isChecked():
open("config_new.json", "wb").write(json.dumps(self.config, indent=1))
@pyqtSlot("int")
def on_checkBox_load_last_anamation_stateChanged(self, state):
self.settings.setValue("load_last_anamation", state)
@pyqtSlot("int")
def on_checkBox_enable_servo_stateChanged(self, state):
self.settings.setValue("enable_servo", state)
@pyqtSlot("int")
def on_checkBox_enable_auto_save_stateChanged(self, state):
self.settings.setValue("enable_auto_save", state)
@pyqtSlot("bool")
def on_action_save_as_triggered(self, state):
file_name = QtGui.QFileDialog.getSaveFileName(None, u"Сохранить в файл", "anim.json", "Animation(*.json)")
if file_name != "":
self.save_to_file(file_name)
@pyqtSlot("bool")
def on_action_save_triggered(self, state):
last_file = self.settings.value("last_animation_file", "").toPyObject()
if last_file != "":
self.save_to_file(last_file)
else:
self.on_action_save_as_triggered(True)
@pyqtSlot("bool")
def on_action_load_triggered(self, state):
fileName = QtGui.QFileDialog.getOpenFileName(None, u"открыть файл", "anim.json", "Animation(*.json)")
if fileName != "":
self.load_from_file(fileName)
@pyqtSlot()
def onTimeout(self):
self.set_cur_time((self.spinBox_cur_time.value() + (self.timer.interval() / 1000.) * self.doubleSpinBox_speed.value()))
@pyqtSlot("bool")
def on_action_copy_triggered(self, state):
self.copied_data = self.get_data_by_time(self.get_cur_time())
@pyqtSlot("bool")
def on_action_insert_triggered(self, state):
if self.copied_data is not None:
self.create_frame(self.get_cur_time(), self.copied_data)
if self.checkBox_enable_auto_save.isChecked():
self.on_action_save_triggered(True)
@pyqtSlot('double')
def on_doubleSpinBox_speed_valueChanged(self, value):
self.settings.setValue("animation_speed", value)
if self.checkBox_enable_auto_save.isChecked():
self.on_action_save_triggered(True)
@pyqtSlot("bool")
def on_action_create_triggered(self, state):
#поверим сеществования фрейма в данном времени
self.create_frame(self.get_cur_time(), self.get_cur_data())
if self.checkBox_enable_auto_save.isChecked():
self.on_action_save_triggered(True)
@pyqtSlot("bool")
def on_action_remove_triggered(self, state):
row = self.listWidget.currentRow()
if row != -1:
self.listWidget.takeItem(row)
if self.checkBox_enable_auto_save.isChecked():
self.on_action_save_triggered(True)
@pyqtSlot('double')
def on_spinBox_cur_time_valueChanged(self, time):
data = self.get_data_by_time(time)
if data is not None:
for index, values in enumerate(data):
self.groups[index].set_servos_data(values)
if time >= self.time_window_pos and time < self.time_window_pos + self.time_window_size:
old_state = self.horizontalSlider_cur_time.blockSignals(True)
self.horizontalSlider_cur_time.setValue((time - self.time_window_pos) /
self.time_window_size * self.horizontalSlider_cur_time.maximum())
self.horizontalSlider_cur_time.blockSignals(old_state)
@pyqtSlot('double')
def on_spinBox_max_time_valueChanged(self, value):
print "on_spinBox_max_time_valueChanged(value:{0})".format(value)
if value < self.get_max_animation_time():
value = self.get_max_animation_time()
self.spinBox_max_time.setValue(value)
self.spinBox_cur_time.setMaximum(value)
self.time_window_size = value
if self.checkBox_enable_auto_save.isChecked():
self.on_action_save_triggered(True)
@pyqtSlot('int')
def on_listWidget_currentRowChanged(self, row):
if row != -1:
item = self.listWidget.item(row)
time = item.data(QtCore.Qt.UserRole).toDouble()[0]
data = item.data(QtCore.Qt.UserRole + 1).toPyObject()
self.set_cur_time(time)
for index, values in enumerate(data):
self.groups[index].set_servos_data(values)
@pyqtSlot()
def on_pushButton_start_stop_clicked(self):
if not self.played:
self.groupBox_settings.setEnabled(False)
self.frame_time_settings.setEnabled(False)
self.pushButton_start_stop.setText(u"Стоп")
self.played = True
self.timer.start()
else:
self.played = False
self.groupBox_settings.setEnabled(True)
self.frame_time_settings.setEnabled(True)
self.pushButton_start_stop.setText(u"Пуск")
self.timer.stop()
@pyqtSlot('int')
def on_horizontalSlider_cur_time_valueChanged(self, value):
time = (value / float(self.horizontalSlider_cur_time.maximum())) * self.time_window_size + self.time_window_pos
self.spinBox_cur_time.setValue(time)
def get_cur_time(self):
return float(self.spinBox_cur_time.value())
def set_cur_time(self, time):
self.spinBox_cur_time.setValue(time % self.spinBox_max_time.value())
def save_to_file(self, file_name):
res = {"animation":[]}
for i in range(self.listWidget.count()):
time = self.listWidget.item(i).data(QtCore.Qt.UserRole).toDouble()[0]
data = self.listWidget.item(i).data(QtCore.Qt.UserRole+1).toPyObject()
res["animation"].append({"time":time, "data":data})
res["speed"] = self.doubleSpinBox_speed.value()
res["max_time"] = self.spinBox_max_time.value()
open(file_name, "wb").write(json.dumps(res))
self.settings.setValue("last_animation_file", file_name)
def load_from_file(self, file_name):
try:
data = json.loads(open(file_name, "rb").read())
print data
state = self.doubleSpinBox_speed.blockSignals(True)
self.doubleSpinBox_speed.setValue(data["speed"])
self.doubleSpinBox_speed.blockSignals(state)
#state = self.spinBox_max_time.blockSignals(True)
self.spinBox_max_time.setValue(data["max_time"])
#self.spinBox_max_time.blockSignals(state)
self.listWidget.clear()
for item in data["animation"]:
self.create_frame(float(item["time"]), item["data"])
self.settings.setValue("last_animation_file", file_name)
except:
pass
def get_max_animation_time(self):
if self.listWidget.count():
return self.listWidget.item(self.listWidget.count() - 1).text().toDouble()[0]
return 0.0
def get_frame_byte_time(self, time):
for i in range(self.listWidget.count()):
if self.listWidget.item(i).data(QtCore.Qt.UserRole).toDouble()[0] == time:
return self.listWidget.item(i)
return None
def get_cur_data(self):
return [g.get_servos_data() for g in self.groups]
def create_frame(self, time, data):
item = self.get_frame_byte_time(time)
if item is None:
item = QtGui.QListWidgetItem()
item.setText(QtCore.QString.number(time))
item.setData(QtCore.Qt.UserRole, time)
item.setData(QtCore.Qt.UserRole + 1, data)
#вставим в нужное место
for i in range(self.listWidget.count()):
if time < self.listWidget.item(i).data(QtCore.Qt.UserRole).toDouble()[0]:
self.listWidget.insertItem(i, item)
break
else:
self.listWidget.addItem(item)
else:
item.setData(QtCore.Qt.UserRole + 1, data)
self.listWidget.setCurrentItem(item)
def get_data_by_time(self, time):
#найдём граничные фреймы.
borders = self.get_borders(time)
#вычислим промежуточное значение углов
if borders is not None:
start_time, end_time = borders[0]
if time == start_time:
self.listWidget.setCurrentItem(borders[1][0])
dt = float(time - start_time)/float(end_time - start_time)
left_border = borders[1][0].data(QtCore.Qt.UserRole + 1).toPyObject()
right_border = borders[1][1].data(QtCore.Qt.UserRole + 1).toPyObject()
result = []
for first_group, last_group in zip(left_border, right_border):
group_data = [first + (last - first) * dt for first, last in zip(first_group, last_group)]
result.append(group_data)
return result
return self.get_cur_data()
def get_borders(self, time):
for i in range(self.listWidget.count() - 1):
cur_time = self.listWidget.item(i).data(QtCore.Qt.UserRole).toDouble()[0]
next_time = self.listWidget.item(i + 1).data(QtCore.Qt.UserRole).toDouble()[0]
if cur_time <= time and next_time > time:
return ((cur_time, next_time), (self.listWidget.item(i), self.listWidget.item(i + 1)))
return None
def __init__(self, recv_queue, send_queue, total_workers):
self.protocol = Protocol(recv_queue, send_queue, total_workers)
self.cities_data = {}
self.top_cities = {}
def __init__(self, recv_queue):
self.protocol = Protocol(recv_queue)
def __init__(self, recv_queue, send_queue, master_queue):
self.protocol = Protocol(recv_queue, send_queue, master_queue)
self.results_per_date = {}
def __init__(self, recv_queue, send_queue, status_queue,
data_cluster_write, data_cluster_read):
self.protocol = Protocol(recv_queue, send_queue, status_queue,
data_cluster_write, data_cluster_read)
self.positives_per_city = {}
def __init__(self, recv_queue, send_queue, master_queue):
self.protocol = Protocol(recv_queue, send_queue, master_queue)
self.positives_per_city = {}
def __init__(self, recv_queue, send_queue):
self.protocol = Protocol(recv_queue, send_queue)
self.total_positivi = 0
self.total_deceduti = 0
