class SystemSettingsWindow(QtWidgets.QWidget): def __init__(self, parent=None): super(SystemSettingsWindow, self).__init__(parent) self.s = parent self.cs = ConfigSystem() self.console = ConsoleThreadOutput() # Creating Widgets self.wp = WidgetsPath(self) self.button_ok = QtWidgets.QPushButton('Save', self) self.button_clear = QtWidgets.QPushButton('Clear', self) self.button_cancel = QtWidgets.QPushButton('Cancel', self) # Setting Up self.button_settings() self.setting_up() self.filling_fields() def button_settings(self): self.button_clear.clicked.connect(self.clear_fields) self.button_cancel.clicked.connect(self.s.close) self.button_ok.clicked.connect(self.ok_button) def ok_button(self): try: self.saving_settings() self.console.raise_text("Saved settings successfully!", 1) except: self.console.raise_text("Unable to save the system settings.", 1) finally: self.s.close() def setting_up(self): self.setLayout( set_lvbox( set_hbox(self.wp), set_hbox(self.button_ok, self.button_clear, self.button_cancel, stretch2=1))) def saving_settings(self): info = self.wp.get_values() self.cs.set_site_settings(info[0], info[1], info[2]) self.cs.save_settings() def filling_fields(self): info = self.cs.get_site_settings() self.wp.set_values(info[0], info[1], info[2]) def clear_fields(self): self.wp.clear_path()
class ShutterControls(QtWidgets.QWidget): def __init__(self): super(ShutterControls, self).__init__() self.console = ConsoleThreadOutput() self.openaction = QPushButton('Open Shutter', self) self.openaction.clicked.connect(self.run_true) self.closeaction = QPushButton('Close Shutter', self) self.closeaction.clicked.connect(self.run_false) self.setLayout(set_hbox(self.openaction, self.closeaction)) def run_true(self): self.console.raise_text("Opening Shutter...", 2) time.sleep(1) if shutter_control(True) == "An Error Occured...": self.console.raise_text("An Error Occured...", 3) time.sleep(1) def run_false(self): self.console.raise_text("Closing Shutter...", 2) time.sleep(1) if shutter_control(False) == "An Error Occured...": self.console.raise_text("An Error Occured...", 3) time.sleep(1)
class SystemSettingsWindow(QtWidgets.QWidget): def __init__(self, parent=None): super(SystemSettingsWindow, self).__init__(parent) self.s = parent self.cs = ConfigSystem() self.console = ConsoleThreadOutput() # Creating Widgets self.wp = WidgetsPath(self) self.button_ok = QtWidgets.QPushButton('Save', self) self.button_clear = QtWidgets.QPushButton('Clear', self) self.button_cancel = QtWidgets.QPushButton('Cancel', self) # Setting Up self.button_settings() self.setting_up() self.filling_fields() def button_settings(self): self.button_clear.clicked.connect(self.clear_fields) self.button_cancel.clicked.connect(self.s.close) self.button_ok.clicked.connect(self.ok_button) def ok_button(self): try: self.saving_settings() self.console.raise_text("Saved settings successfully!", 1) except: self.console.raise_text("Unable to save the system settings.", 1) finally: self.s.close() def setting_up(self): self.setLayout(set_lvbox(set_hbox(self.wp), set_hbox(self.button_ok, self.button_clear, self.button_cancel, stretch2=1))) def saving_settings(self): info = self.wp.get_values() self.cs.set_site_settings(info[0], info[1], info[2], info[3], info[4]) self.cs.save_settings() def filling_fields(self): info = self.cs.get_site_settings() self.wp.set_values(info[0], info[1], info[2], info[3], info[4]) def clear_fields(self): self.wp.clear_path()
class DarkShooterThread(QtCore.QThread): def __init__(self, timeSleep): self.continuous = None super(DarkShooterThread, self).__init__() self.console = ConsoleThreadOutput() self.s = timeSleep self.ss = SThread() self.settings = SettingsCamera() def run(self): self.s = int(self.settings.get_camera_settings()[4]) while self.continuous: time.sleep(self.s) if self.continuous: self.console.raise_text("Taking dark photo", 1) self.ss.take_dark()
class SchedSunMoonPositions(metaclass=Singleton): def __init__(self, sunElevationField, moonElevationField, moonPhaseField): self.sunElevationField = sunElevationField self.moonElevationField = moonElevationField self.moonPhaseField = moonPhaseField self.console = ConsoleThreadOutput() self.thread_sun_moon = QThreadSunMoon() self.thread_sun_moon.signal_update_sun_moon.connect(self.refresh_info) self.thread_sun_moon.start() def refresh_info(self, info): try: self.sunElevationField.setText(info[0]) self.moonElevationField.setText(info[1]) self.moonPhaseField.setText(info[2]) except Exception as e: self.console.raise_text( "Error sun and moon Scheduler\n{}".format(e))
class SchedSunMoonPositions(metaclass=Singleton): def __init__(self, sunElevationField, moonElevationField, moonPhaseField): self.sunElevationField = sunElevationField self.moonElevationField = moonElevationField self.moonPhaseField = moonPhaseField self.console = ConsoleThreadOutput() self.thread_sun_moon = QThreadSunMoon() self.thread_sun_moon.signal_update_sun_moon.connect(self.refresh_info) self.thread_sun_moon.start() def refresh_info(self, info): try: self.sunElevationField.setText(info[0]) self.moonElevationField.setText(info[1]) self.moonPhaseField.setText(info[2]) except Exception as e: self.console.raise_text("Error sun and moon Scheduler\n{}".format(e))
class ContinuousShooterThread(QtCore.QThread): signalAfterShooting = QtCore.pyqtSignal(name="signalAfterShooting") def __init__(self, timeSleep): super(ContinuousShooterThread, self).__init__() self.continuous = True self.s = timeSleep self.ss = SThread() self.ss.started.connect(self.thread_iniciada) self.console = ConsoleThreadOutput() self.count = 0 def set_sleep_time(self, t): self.s = t def run(self): self.count = 1 while self.continuous: try: self.ss.start() while self.ss.isRunning(): time.sleep(1) except Exception as e: print(e) time.sleep(self.s) self.signalAfterShooting.emit() def start_continuous_shooter(self): self.continuous = True def stop_continuous_shooter(self): self.count = 1 self.continuous = False def thread_iniciada(self): self.console.raise_text("Taking photo N: {}".format(self.count), 2) self.count += 1
class ContinuousShooterThread(QtCore.QThread): """classe para modo manual""" signalAfterShooting = QtCore.pyqtSignal(name="signalAfterShooting") signal_temp = QtCore.pyqtSignal(name="signalTemp") def __init__(self, timeSleep): super(ContinuousShooterThread, self).__init__() self.continuous = True self.s = timeSleep self.ss = SThread() self.ss.started.connect(self.thread_iniciada) self.console = ConsoleThreadOutput() self.count = 0 self.wait_temperature = False self.not_two_dark = True def set_sleep_time(self, t): self.s = t def run(self): self.count = 1 while self.continuous: try: self.signal_temp.emit() if self.wait_temperature: self.ss.start() while self.ss.isRunning(): time.sleep(1) except Exception as e: print(e) time.sleep(self.s) self.signalAfterShooting.emit() def start_continuous_shooter(self): self.continuous = True def stop_continuous_shooter(self): self.wait_temperature = False self.continuous = False self.not_two_dark = False self.console.raise_text("Taking dark photo", 1) self.ss.take_dark() time.sleep(1) self.count = 1 def thread_iniciada(self): if self.count == 1: self.console.raise_text("Taking dark photo", 1) self.ss.take_dark() self.count += 1 self.not_two_dark = False elif self.count != 1: self.console.raise_text("Taking photo N: {}".format(self.count), 1) self.count += 1
class SettingsWindow(QtWidgets.QWidget): def __init__(self, parent=None): super(SettingsWindow, self).__init__(parent) self.p = parent self.console = ConsoleThreadOutput() self.site = WidgetsSite(self) self.geo = WidgetsGeography(self) self.sun = WidgetsSun(self) self.button_clear = QtWidgets.QPushButton('Clear', self) self.button_ok = QtWidgets.QPushButton('Save', self) self.button_cancel = QtWidgets.QPushButton('Cancel', self) self.button_settings() # Init Interface self.setting_up() self.refresh_all_fields() def button_settings(self): self.button_clear.clicked.connect(self.clear_all) self.button_cancel.clicked.connect(self.func_cancel) self.button_ok.clicked.connect(self.func_ok) def func_cancel(self): self.p.close() #self.clear_all() def func_ok(self): try: self.save_settings() self.console.raise_text("Project settings successfully saved!", 1) except: self.console.raise_text("Unable to save the project settings.", 3) finally: self.p.close() self.clear_all() self.refresh_all_fields() def clear_all(self): self.site.clear_site() self.geo.clear_geography() self.sun.clear_sun() def refresh_all_fields(self): try: st = ConfigProject() infoSite = st.get_site_settings() self.site.set_site_info(infoSite[0], infoSite[1], infoSite[2]) infoGeo = st.get_geographic_settings() self.geo.set_geography(infoGeo[0], infoGeo[1], infoGeo[2], infoGeo[3], infoGeo[4]) infoSun = st.get_moonsun_settings() self.sun.set_sun(str(infoSun[0]), infoSun[1], str(infoSun[2]), str(infoSun[3])) except Exception as e: print(e) def save_settings(self): try: st = ConfigProject() self.save_site(st) self.save_geo(st) self.save_sun(st) st.save_settings() except Exception as e: print(e) def save_site(self, set): info1 = self.site.get_site_info() set.set_site_settings(info1[0], info1[1], info1[2]) def save_geo(self, set): info2 = self.geo.get_geography() set.set_geographic_settings(info2[0], info2[1], info2[2], info2[3], info2[4]) def save_sun(self, set): info3 = self.sun.get_sun() set.set_moonsun_settings(info3[0], info3[1], info3[2], info3[3]) def setting_up(self): self.setLayout( set_lvbox( set_hbox(self.site), set_hbox(self.geo), set_hbox(self.sun), set_hbox(self.button_ok, self.button_clear, self.button_cancel, stretch2=1)))
class SThread(QtCore.QThread): """ Threads são fluxos de programas que executam em paralelo dentro de uma aplicação, isto é,\ uma ramificação de uma parte da aplicação que é executada de forma independente e\ escalonada independentemente do fluxo inicial da aplicação. Fonte: http://imasters.com.br/artigo/20127/py/threads-em-python/?trace=1519021197&source=single """ def __init__(self): super(SThread, self).__init__() self.prefix = None self.exposure_time = None self.binning = None self.get_level1 = None self.get_level2 = None self.get_axis_xi = None self.get_axis_xf = None self.get_axis_yi = None self.get_axis_yf = None self.get_ignore_crop = None self.console = ConsoleThreadOutput() self.get_image_tif = None self.get_image_fit = None self.get_image_png = None self.temperatura = None self.eof = EphemObserverFactory() self.obs = None self.path = None self.tempo = None self.info_matrix = None self.img = None self.new_image_name = None self.selected_filter = None self.dark_or_open = "Closed" self.one_photo = None self.for_headers_dic = {} self.lock = Locker() self.info_matrix = [] self.filter_split_label = None self.count_aux = 0 self.kwargs = None self.message_console_one_photo = None self.roda_filtros = FilterControl() def set_config_take_image(self): """ seta as configuracoes para se tirar uma foto """ try: info_cam = get_camera_settings() self.for_headers_dic['Set Temperature'] = info_cam[0] self.for_headers_dic['????Tempo de espera'] = info_cam[1] info_image = get_image_settings() try: self.get_level1 = float(info_image[0]) except Exception as e: # print("self.get_level1 = 0.1 -> {}".format(e)) self.get_level1 = 0.1 try: self.get_level2 = float(info_image[1]) except Exception as e: # print("self.get_level2 = 0.99 -> {}".format(e)) self.get_level2 = 0.99 try: self.get_axis_xi = float(info_image[2]) except Exception as e: # print("self.get_axis_xi = 0 -> {}".format(e)) self.get_axis_xi = 0 try: self.get_axis_xf = float(info_image[3]) except Exception as e: # print("self.get_axis_xf = 0 -> {}".format(e)) self.get_axis_xf = 0 try: self.get_axis_yi = float(info_image[4]) except Exception as e: # print("self.get_axis_yi = 0 -> {}".format(e)) self.get_axis_yi = 0 try: self.get_axis_yf = float(info_image[5]) except Exception as e: # print("self.get_axis_yf = 0 -> {}".format(e)) self.get_axis_yf = 0 try: self.get_ignore_crop = info_image[6] except Exception as e: print("self.get_ignore_crop = True -> {}".format(e)) self.get_ignore_crop = True try: self.get_image_png = info_image[7] except Exception as e: print("self.get_image_png = True -> {}".format(e)) self.get_image_png = True try: self.get_image_tif = info_image[8] except Exception as e: print("self.get_image_tif = True -> {}".format(e)) self.get_image_tif = True try: self.get_image_fit = info_image[9] except Exception as e: print("self.get_image_fit = True -> {}".format(e)) self.get_image_fit = True try: self.filter_split_label = get_filter_settings() except Exception as e: print("get_filter_settings() -> {}".format(e)) try: self.append_camera_settings() except Exception as e: print( "self.append_camera_settings() in set_config_take_image -> {}" .format(e)) except Exception as e: print("Try ini definitive -> {}".format(e)) def recebe_argumento(self, kwargs): self.kwargs = kwargs def args_one_photo(self, filter_args, kwargs): self.selected_filter = filter_args if kwargs == "Closed": self.kwargs = 1 else: self.kwargs = 0 self.one_photo = True def run(self): if self.kwargs == 0: try: self.create_image_open() except Exception as e: print("self.create_image_open() -> {}".format(e)) else: try: self.create_image_close() except Exception as e: print("self.create_image_close() -> {}".format(e)) def create_image_open(self): self.roda_filtros.open_shutter() self.set_config_take_image() self.lock.set_acquire() my_list = get_wish_filters_settings() # list of schedule try: if self.count_aux < len(my_list): if self.one_photo: index_of_dic = self.selected_filter else: index_of_dic = str(my_list[self.count_aux]) self.valores_principais_wish_filter(index_of_dic) self.count_aux += 1 else: self.count_aux = 0 if self.one_photo: index_of_dic = self.selected_filter else: index_of_dic = str(my_list[self.count_aux]) self.valores_principais_wish_filter(index_of_dic) self.count_aux += 1 except Exception as e: print("Try filter ini -> {}".format(e)) project_infos = get_project_settings() name_observatory = project_infos[2][1] self.path, self.tempo = set_path() self.new_image_name = str( self.prefix) + "_" + str(name_observatory) + "_" + str(self.tempo) new_image_name = self.path + str(self.new_image_name) try: self.info_matrix = SbigDriver.photoshoot(self.exposure_time, self.binning, 0) except Exception as e: print("self.info_matrix = SbigDriver.photoshoot ERROR -> " + str(e)) self.for_headers_dic['Open or close shutter'] = "OPEN" self.save_image_format(new_image_name) self.for_headers_dic = {} self.one_photo = False self.init_image() self.lock.set_release() def create_image_close(self): self.roda_filtros.close_shutter() my_list = get_wish_filters_settings() # list of schedule my_list = set(my_list) my_list = sorted(my_list) count_aux = 0 while count_aux < len(my_list): self.set_config_take_image() self.lock.set_acquire() if self.one_photo: index_of_dic = self.selected_filter count_aux = 100 else: index_of_dic = str(my_list[count_aux]) self.valores_principais_wish_filter(index_of_dic) project_infos = get_project_settings() name_observatory = project_infos[2][1] self.path, self.tempo = set_path() self.new_image_name = "DARK-" + str( self.prefix) + "_" + str(name_observatory) + "_" + str( self.tempo) new_image_name = self.path + str(self.new_image_name) try: self.info_matrix = SbigDriver.photoshoot( self.exposure_time, self.binning, 1) except Exception as e: print("self.info_matrix = SbigDriver.photoshoot ERROR -> " + str(e)) self.for_headers_dic['Open or close shutter'] = "CLOSED" self.save_image_format(new_image_name) self.for_headers_dic = {} count_aux += 1 self.init_image() self.lock.set_release() self.one_photo = False def filter_wheel_control(self, wish_filter_int): try: sleep(1) wish_filter_int = int(wish_filter_int) self.roda_filtros.filter_wheel_control(wish_filter_int) sleep(1) except Exception as e: self.roda_filtros.home_reset() print(e) def save_image_format(self, new_image_name): if not os.path.isdir(self.path): os.makedirs(self.path) if self.one_photo: print(self.path) self.for_headers_dic['Start Time'] = self.tempo try: self.temperatura = SbigDriver.get_temperature() self.temperatura = "{0:.2f}".format(float(self.temperatura[3])) # self.temperatura = "25" self.for_headers_dic['Temperature'] = self.temperatura except Exception as e: print("Exception self.temperatura -> {}".format(e)) self.for_headers_dic['Temperature'] = "???" if self.get_image_png: try: save_png(self.info_matrix, new_image_name, self.for_headers_dic) except Exception as e: print("Exception save_png() -> {}".format(e)) if self.get_image_tif: try: save_tif(self.info_matrix, new_image_name) if self.one_photo: print(new_image_name) except Exception as e: print("Exception save_tif() -> {}".format(e)) if self.get_image_fit: try: save_fit(self.info_matrix, new_image_name, self.for_headers_dic) except Exception as e: print("Exception save_fit() -> {}".format(e)) if not self.get_image_fit and not self.get_image_tif and not self.get_image_fit: try: save_png(self.info_matrix, new_image_name, self.for_headers_dic) except Exception as e: print("Exception save_png() -> {}".format(e)) def valores_principais_wish_filter(self, index_of_dic): aux = self.filter_split_label[str(index_of_dic)][0] aux = list(aux) ''' aux[0] = self.prefix aux[2] = self.exposure_time aux[3] = self.binning aux[4] = wish filter ''' self.prefix = str(aux[0]) self.exposure_time = float(aux[2]) if self.exposure_time <= 0.12: self.exposure_time = 0.12 * 100 elif self.exposure_time >= 3600: self.exposure_time = 3600 * 100 else: self.exposure_time = float(aux[2]) * 100 self.exposure_time = int(self.exposure_time) self.binning = int(aux[3]) self.filter_wheel_control(int(aux[4])) self.append_filters_settings(aux) def append_camera_settings(self): try: project_infos = get_project_settings() try: self.obs = self.eof.create_observer( longitude=project_infos[0][1], latitude=project_infos[0][0], elevation=project_infos[1][0]) now_datetime = datetime.utcnow() self.obs.date = ephem.date(now_datetime) sun = ephem.Sun(self.obs) moon = ephem.Moon(self.obs) frac = moon.moon_phase sun_alt = ephem.degrees(sun.alt) moon_alt = ephem.degrees(moon.alt) sun_elevation = "{:.2f}".format(float(math.degrees(sun_alt))) moon_elevation = "{:.2f}".format(float(math.degrees(moon_alt))) moon_phase = "{0:.2f}".format(frac * 100) except Exception as e: print("ephem update -> {}".format(e)) self.for_headers_dic['Latitude'] = str(project_infos[0][0]) self.for_headers_dic['Longitude'] = str(project_infos[0][1]) self.for_headers_dic['Elevation(m)'] = str(project_infos[0][2]) self.for_headers_dic['Pressure(mb)'] = str(project_infos[0][3]) self.for_headers_dic['Sun Elevation'] = str(sun_elevation) self.for_headers_dic['Ignore Lunar Position'] = str( project_infos[1][1]) self.for_headers_dic['Moon Elevation'] = str(moon_elevation) self.for_headers_dic['Moon Phase'] = str(moon_phase) self.for_headers_dic['Name'] = str(project_infos[2][0]) self.for_headers_dic['Observatory'] = str(project_infos[2][1]) self.for_headers_dic['Imager ID'] = str(project_infos[2][2]) self.for_headers_dic['get_level1'] = str(self.get_level1) self.for_headers_dic['get_level2'] = str(self.get_level2) self.for_headers_dic['get_axis_xi'] = str(self.get_axis_xi) self.for_headers_dic['get_axis_xf'] = str(self.get_axis_xf) self.for_headers_dic['get_axis_yi'] = str(self.get_axis_yi) self.for_headers_dic['get_axis_yf'] = str(self.get_axis_yf) self.for_headers_dic['get_ignore_crop'] = str(self.get_ignore_crop) except Exception as e: print("run append_camera_settings() -> {}".format(e)) def append_filters_settings(self, aux): try: self.for_headers_dic['Filter Label'] = str(aux[0]) self.for_headers_dic['Filter Wavelength'] = str(aux[1]) self.for_headers_dic['Exposure'] = str(self.exposure_time) self.for_headers_dic['Binning'] = str(aux[3]) self.for_headers_dic['Filter Position'] = str(aux[4]) except Exception as e: print("run append_filters_settings() -> {}".format(e)) def get_new_image_name(self, local_name_image): self.console.raise_text( "Image saved in " + str(local_name_image) + ".png", 1) def init_image(self): try: print("\nAAAAAAAAAAAAAAAAAAAAAA\n") # for i in self.info_matrix: # print(i) self.img = Image(self.path, self.new_image_name) except Exception as e: print("Image('', '') -> {}".format(e)) self.img = Image('', '') return self.img def get_image_info(self): return self.img
class Fan(metaclass=Singleton): def __init__(self): self.lock = Locker() self.console = ConsoleThreadOutput() def set_fanField(self, fanField): self.fanField = fanField def fan_status(self): # Acquiring the Lock self.lock.set_acquire() status = True try: # Doing requisition to Driver status = SbigDriver.is_fanning() except Exception as e: self.console.raise_text("Error acquiring the status of Fan.\n{}".format(e)) # Release the Lock self.lock.set_release() return "ON" if status else "OFF" def refresh_fan_status(self): self.fanField.setText(self.fan_status()) def set_fan(self): t = Thread(target=self.s_fan) t.start() def s_fan(self): self.lock.set_acquire() try: if SbigDriver.is_fanning(): SbigDriver.stop_fan() self.fanField.setText('Fan Off') else: SbigDriver.start_fan() self.fanField.setText('Fan On') except Exception as e: self.console.raise_text("Error off/on the Fan.\n{}".format(e)) finally: self.lock.set_release() self.fanField.setText(self.fan_status()) def set_fan_off(self): self.lock.set_acquire() try: SbigDriver.stop_fan() except Exception as e: self.console.raise_text("Error off/on the Fan.\n{}".format(e)) finally: self.lock.set_release() self.fanField.setText(self.fan_status()) def set_fan_on(self): self.lock.set_acquire() try: SbigDriver.start_fan() except Exception as e: self.console.raise_text("Error off/on the Fan.\n{}".format(e)) finally: self.lock.set_release() self.fanField.setText(self.fan_status())
class EphemerisShooter(QtCore.QThread): ''' classe para modo automatico ''' signal_started_shooting = QtCore.pyqtSignal(name="signalStartedShooting") signal_temp = QtCore.pyqtSignal(name="signalTemp") def __init__(self): super(EphemerisShooter, self).__init__() self.camconfig = SettingsCamera() self.camconfig.setup_settings() infocam = self.camconfig.get_camera_settings() self.ObserverFactory = EphemObserverFactory() self.continuousShooterThread = ContinuousShooterThread(int(infocam[4])) self.console = ConsoleThreadOutput() self.config = ConfigProject() info = self.config.get_geographic_settings() self.latitude = info[0] # '-45.51' self.longitude = info[1] # '-23.12' self.elevation = info[2] # 350 info_sun = self.config.get_moonsun_settings() self.max_solar_elevation = float(info_sun[0]) # -12 self.ignore_lunar_position = info_sun[1] self.max_lunar_elevation = float(info_sun[2]) # 8 self.max_lunar_phase = float(info_sun[3]) # 1 self.wait_temperature = False print(int(infocam[4])) try: self.s = int(infocam[4]) self.continuousShooterThread.set_sleep_time(self.s) except Exception as e: self.s = 5 self.shootOn = False self.controller = True self.count = 1 def refresh_data(self): try: info = self.config.get_geographic_settings() self.latitude = info[0] # '-45.51' self.longitude = info[1] # '-23.12' self.elevation = info[2] # 350 infosun = self.config.get_moonsun_settings() self.max_solar_elevation = float(infosun[0]) # -12 self.ignore_lunar_position = infosun[1] self.max_lunar_elevation = float(infosun[2]) # 8 self.max_lunar_phase = float(infosun[3]) # 1 except Exception as e: self.console.raise_text("Exception thrown to acquire information\n" "Please set an observatory information on settings\n" + str(e), level=3) self.latitude = 0 self.longitude = 0 self.elevation = 0 self.max_solar_elevation = 0 self.max_lunar_elevation = 0 self.max_lunar_phase = 0 infocam = self.camconfig.get_camera_settings() try: self.s = int(infocam[4]) except Exception as e: self.s = 0 def calculate_moon(self, obs): aux = obs aux.compute_pressure() aux.horizon = '8' moon = ephem.Moon(aux) return aux.previous_setting(moon), aux.next_rising(moon) def calculate_sun(self, obs): aux = obs aux.compute_pressure() aux.horizon = '-12' sun = ephem.Sun(aux) return aux.previous_setting(sun), aux.next_rising(sun) def set_solar_and_lunar_parameters(self, maxSolarElevation, maxLunarElevation, maxLunarPhase): self.max_solar_elevation = maxSolarElevation self.max_lunar_elevation = maxLunarElevation self.max_lunar_phase = maxLunarPhase def run(self): self.refresh_data() obs = self.ObserverFactory.create_observer(longitude=self.longitude, latitude=self.latitude, elevation=self.elevation) self.controller = True self.shootOn = False c = 0 flag = 0 try: while self.controller: obs.date = ephem.date(datetime.datetime.utcnow()) sun = ephem.Sun(obs) moon = ephem.Moon(obs) # frac = moon.moon_phase frac = float(moon.moon_phase) * 100.0 a = ephem.degrees(sun.alt) b = ephem.degrees(str(moon.alt)) # Variavel de controle do shooter t = 0 # print("\n\n") # print("math.degrees(a) = " + str(math.degrees(a))) # print("self.max_solar_elevation = " + str(self.max_solar_elevation)) # print("self.ignore_lunar_position = " + str(self.ignore_lunar_position)) # print("math.degrees(b) = " + str(math.degrees(b))) # print("self.max_lunar_elevation = " + str(self.max_lunar_elevation)) # print("self.max_lunar_phase = " + str(self.max_lunar_phase)) # print("\n\n") ''' obs.date = ephem.date(now_datetime) sun = ephem.Sun() sun.compute(obs) moon = ephem.Moon() moon.compute(obs) frac = float(moon.moon_phase) * 100.0 ag_s = float(repr(sun.alt)) s_ag = math.degrees(ag_s) ag_m = float(repr(moon.alt)) m_ag = math.degrees(ag_m) ''' # flag = 0 ephem_out = False # **************************************** Ephem Loop **************************************** if self.ignore_lunar_position: if (float(math.degrees(a)) <= self.max_solar_elevation) and (flag == 0): if not self.shootOn: if not c: self.signal_started_shooting.emit() c = 1 # flag = 1 self.signal_temp.emit() time.sleep(5) if self.wait_temperature: # Iniciar as Observações self.start_taking_photo() self.shootOn = True self.log_ephem_infos() flag = 1 if (float(math.degrees(a)) > self.max_solar_elevation) and (flag == 1): if self.shootOn: # Finalizar as Observações self.stop_taking_photo() c = 0 flag = 0 self.t = False self.shootOn = False else: if frac < self.max_lunar_phase: if (float(math.degrees(a)) <= self.max_solar_elevation) and (float(math.degrees(b)) <= self.max_lunar_elevation) and (flag == 0): if not self.shootOn: if not c: self.signal_started_shooting.emit() c = 1 # flag = 1 self.signal_temp.emit() time.sleep(5) if self.wait_temperature: # Iniciar as Observações self.start_taking_photo() self.shootOn = True self.log_ephem_infos() flag = 1 if (float(math.degrees(a)) > self.max_solar_elevation or float(math.degrees(b)) > self.max_lunar_elevation) and (flag == 1): if self.shootOn: # Finalizar as Observações self.stop_taking_photo() c = 0 flag = 0 self.t = False self.shootOn = False else: if (float(math.degrees(a)) <= self.max_solar_elevation) and (float(math.degrees(b)) <= float(5.0)) and (flag == 0): if not self.shootOn: if not c: self.signal_started_shooting.emit() c = 1 # flag = 1 self.signal_temp.emit() time.sleep(5) if self.wait_temperature: # Iniciar as Observações self.start_taking_photo() self.shootOn = True self.log_ephem_infos() flag = 1 if (float(math.degrees(a)) > self.max_solar_elevation or float(math.degrees(b)) > float(5.0)) and (flag == 1): if self.shootOn: # Finalizar as Observações self.stop_taking_photo() c = 0 flag = 0 self.t = False self.shootOn = False # **************************************** Ephem Loop **************************************** ''' if float(math.degrees(a)) < self.max_solar_elevation or t == 1: if (not self.ignore_lunar_position and float(math.degrees(b)) < self.max_lunar_elevation and frac < self.max_lunar_phase) or self.ignore_lunar_position: if not self.shootOn: if not c: self.signal_started_shooting.emit() c = 1 self.signal_temp.emit() time.sleep(5) if self.wait_temperature: # Iniciar as Observações self.start_taking_photo() self.shootOn = True else: if self.shootOn: # Finalizar as Observações self.stop_taking_photo() c = 0 self.t = False self.shootOn = False time.sleep(5) ''' except Exception as e: self.console.raise_text("Exception no Ephemeris Shooter -> " + str(e)) def stop_shooter(self): self.controller = False if self.continuousShooterThread.isRunning(): self.continuousShooterThread.stop_continuous_shooter() """ if not self.continuousShooterThread.wait_temperature: self.continuousShooterThread.stop_continuous_shooter() """ def start_taking_photo(self): self.continuousShooterThread.set_sleep_time(self.s) self.continuousShooterThread.start_continuous_shooter() self.continuousShooterThread.start() def stop_taking_photo(self): self.continuousShooterThread.stop_continuous_shooter() def log_ephem_infos(self): info_start_end = result() start_time = str(info_start_end[0]) start_field = start_time[:-10] + " UTC" end_time = str(info_start_end[1]) end_field = end_time[:-10] + " UTC" ''' time_obs_time = str(info_start_end[2]).split(":") time_obs_time = [z.split(".")[0] for z in time_obs_time] time_obs_field = time_obs_time[0] + ":" + time_obs_time[1] + " Hours" ''' # self.console.raise_text("Start Time: " + start_field + "; End Time: " + end_field, 2) self.console.save_log("Start Time: " + start_field + "; End Time: " + end_field)
class ContinuousShooterThread(QtCore.QThread): ''' classe para modo manual ''' signalAfterShooting = QtCore.pyqtSignal(name="signalAfterShooting") signal_temp = QtCore.pyqtSignal(name="signalTemp") def __init__(self, timeSleep): super(ContinuousShooterThread, self).__init__() self.continuous = True self.s = timeSleep self.ds = DarkShooterThread(self.s) ''' SThread manda para o Sbigdriver as informações para se tirar a foto em si. ''' self.ss = SThread() self.ss.started.connect(self.thread_iniciada) self.console = ConsoleThreadOutput() self.count = 0 self.wait_temperature = False self.not_two_dark = True self.one_photo = False def set_sleep_time(self, t): self.s = t def run(self): self.count = 1 while self.continuous: if not self.ss.check_connection(): self.console.raise_text("Connection Lost!", 3) time.sleep(1) self.console.raise_text("Attempting Reconnection...", 2) time.sleep(1) status = self.ss.reconnect() while (not status[0] and status[2]) and \ (datetime.now() < datetime.now() + timedelta(seconds=self.s)): continue if status[0] and status[2]: self.console.raise_text("Successfully Reconnected!", 1) time.sleep(1) else: self.console.raise_text("Reconnection Failed. Aborting...", 3) time.sleep(1) self.stop_continuous_shooter() try: self.signal_temp.emit() if self.wait_temperature: self.ss.start() self.ds.start() while self.ss.isRunning(): time.sleep(1) except Exception as e: print(e) # time.sleep(self.s) self.signalAfterShooting.emit() def start_continuous_shooter(self): """ if not self.one_photo: self.shutter_control(True) """ shutter_control(True) self.continuous = True self.ds.continuous = True def stop_continuous_shooter(self): if self.wait_temperature: self.ds.continuous = False self.wait_temperature = False self.continuous = False self.not_two_dark = False shutter_control(False) self.console.raise_text("Taking dark photo", 1) self.ss.take_dark() time.sleep(1) self.count = 1 else: self.ds.continuous = False self.wait_temperature = False self.continuous = False self.not_two_dark = False shutter_control(False) time.sleep(1) self.count = 1 def stop_one_photo(self): self.one_photo = False self.wait_temperature = False self.continuous = False self.count = 1 self.exit() def thread_iniciada(self): if self.one_photo: self.console.raise_text("Taking photo", 1) self.stop_one_photo() elif self.count == 1 and not self.one_photo: self.console.raise_text("Taking dark photo", 1) self.ss.take_dark() self.count += 1 self.not_two_dark = False elif self.count != 1 and not self.one_photo: self.console.raise_text("Taking photo N: {}".format(self.count), 1) self.count += 1 '''
class SequenceFilters(QtWidgets.QWidget): # Cria os campos e espaços no menu filter sequence_filters window def __init__(self, parent=None): super(SequenceFilters, self).__init__(parent) # Instance attributes create_filtros_disponiveis_group self.filters_disp = None self.showfilters = None # Instance attributes create_wish_filters_group self.wish_sequence_filters_l = None self.showfiltersl = None self.obs_msg = None # Instance attributes create_push_button_group self.saveButton = None self.cancelButton = None self.clearButton = None self.sequencia_filtros = SettingsSequenceFilters() self.filters_disp_var = None self.console = ConsoleThreadOutput() self.count_aux = 0 self.seq_filtros_parent = parent grid = QGridLayout() grid.addWidget(self.create_filtros_disponiveis_group(), 2, 0) grid.addWidget(self.create_wish_filters_group(), 4, 0) grid.addWidget(self.create_push_button_group(), 5, 0) self.setLayout(grid) self.setWindowTitle("Acquisition Schedule") self.setting_values() def get_sequence_filters_settings(self): settings = SettingsSequenceFilters() info = settings.get_sequence_filters_settings() return info def create_filtros_disponiveis_group(self): group_box = QGroupBox("&Available Filters:") self.filters_disp = QtWidgets.QLabel( str(self.available_filters_and_exposure_time())) self.filters_disp.setAlignment(QtCore.Qt.AlignVCenter | QtCore.Qt.AlignVCenter) group_box.setLayout(set_lvbox(set_hbox(self.filters_disp))) return group_box def create_wish_filters_group(self): group_box = QGroupBox("&Filter Sequence:") self.wish_sequence_filters_l = QtWidgets.QLineEdit(self) self.wish_sequence_filters_l.setMinimumWidth(250) available_filters_list_and_commons = get_filter_settings() available_filters_list_and_commons = list( available_filters_list_and_commons) available_filters_list_and_commons.append(',') permited_filters = '' for x in available_filters_list_and_commons: permited_filters += ' ' + str(x) self.obs_msg = QtWidgets.QLabel("Only %s are allowed allowed" % permited_filters) self.obs_msg.setAlignment(QtCore.Qt.AlignVCenter | QtCore.Qt.AlignVCenter) group_box.setLayout( set_lvbox(set_hbox(self.wish_sequence_filters_l), set_hbox(self.obs_msg))) return group_box def create_push_button_group(self): group_box = QGroupBox() self.saveButton = QPushButton("Save") self.saveButton.clicked.connect(self.button_ok_func) self.cancelButton = QPushButton("Cancel") self.cancelButton.clicked.connect(self.func_cancel) group_box.setLayout( set_lvbox(set_hbox(self.saveButton, self.cancelButton))) return group_box def button_ok_func(self): try: available_filters_list_and_commons = get_filter_settings() available_filters_list_and_commons = list( available_filters_list_and_commons) available_filters_list_and_commons.append(',') available_filters_list_and_commons.append(' ') # Percorre a string que está na box e testa caracter por caracter, permitindo somente numeros de filtors # disponiveis e ','. for x in self.wish_sequence_filters_l.text(): if x not in available_filters_list_and_commons: list_save_ok = False break else: list_save_ok = True if list_save_ok: self.sequencia_filtros.set_sequence_filters_settings( self.wish_sequence_filters_l.text()) self.sequencia_filtros.save_settings() self.console.raise_text( "Sequence Filters %s successfully saved!" % self.wish_sequence_filters_l.text(), 1) else: print("Sequence Filters settings were not saved") self.console.raise_text( "Sequence Filters settings were not saved.", 3) error_msg = '' for x in available_filters_list_and_commons: error_msg += ' ' + str(x) QMessageBox.question(self, 'Error message', "Only %s are allowed!" % error_msg, QMessageBox.Ok) except Exception as e: print("Sequence Filters settings were not saved -> {}".format(e)) self.console.raise_text( "Sequence Filters settings were not saved.", 3) def func_cancel(self): self.seq_filtros_parent.close() def setting_values(self): info = self.get_sequence_filters_settings() self.set_values(info) def get_values(self): return self.wish_sequence_filters.text() def set_values(self, wish_sequence_filters): self.wish_sequence_filters_l.setText(wish_sequence_filters) def available_filters_and_exposure_time(self): try: filter_split_label = get_filter_settings() except Exception as e: print("get_filter_settings() -> {}".format(e)) show_filters = '' for filter_position_number in filter_split_label: filter_name = filter_split_label[filter_position_number][0] filter_position_number = str(filter_position_number) filter_name_str = str(filter_name[0]) exposure_time_str = str(filter_name[2]) show_filters += str( filter_position_number) + ": Filter - " + filter_name_str[:3] if len(filter_name_str) == 1: show_filters += " Exposure Time(s): " + exposure_time_str + "\n" elif len(filter_name_str) == 2: show_filters += " Exposure Time(s): " + exposure_time_str + "\n" else: show_filters += " Exposure Time(s): " + exposure_time_str + "\n" return show_filters
class SettingsImageWindow(QtWidgets.QWidget): # Cria os campos e espaços no menu image window def __init__(self, parent=None): super(SettingsImageWindow, self).__init__(parent) # Instance attributes create_image_contrast_group self.getlevel1 = None self.getlevel1l = None self.getlevel2 = None self.getlevel2l = None # Instance attributes create_crop_group self.ignore_crop_l = None self.crop_msg = None self.crop_xi = None self.getcropxi_l = None self.crop_xf = None self.getcropxf_l = None self.crop_yi = None self.getcropyi_l = None self.crop_yf = None self.getcropyf_l = None # Instance attributes create_type_image_group self.image_png_l = None self.image_tif_l = None self.image_fit_l = None # Instance attributes create_push_button_group self.saveButton = None self.cancelButton = None self.clearButton = None self.image_settings = SettingsImage() self.camera = Camera() self.console = ConsoleThreadOutput() self.image_parent = parent self.lock = Locker() grid = QGridLayout() grid.addWidget(self.create_image_contrast_group(), 2, 0) grid.addWidget(self.create_crop_group(), 3, 0) grid.addWidget(self.create_type_image_group(), 4, 0) grid.addWidget(self.create_push_button_group(), 5, 0) self.setLayout(grid) self.setWindowTitle("Imager Box") self.setting_values() def get_image_settings(self): settings = SettingsImage() info = settings.get_image_settings() return info def get_pixels(self): info = self.get_info_pixels() return int(info[-2]), int(info[-1]) def get_info_pixels(self): # Function to get the CCD Info # This function will return [Pixels] ret = None self.lock.set_acquire() try: ret = tuple(ccdinfo()) except Exception as e: self.console.raise_text( "Failed to get camera information.\n{}".format(e)) finally: self.lock.set_release() return ret def create_image_contrast_group(self): group_box = QGroupBox("&Image Contrast:") group_box.setCheckable(True) group_box.setChecked(True) self.getlevel1 = QtWidgets.QLabel("Bottom Level:", self) self.getlevel1.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter) self.getlevel1l = QtWidgets.QLineEdit(self) self.getlevel1l.setMaximumWidth(50) self.getlevel1l.setValidator(QIntValidator(-100, 30)) self.getlevel2 = QtWidgets.QLabel("Top Level:", self) self.getlevel2.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter) self.getlevel2l = QtWidgets.QLineEdit(self) self.getlevel2l.setMaximumWidth(50) self.getlevel2l.setValidator(QIntValidator(-100, 30)) group_box.setLayout( set_lvbox( set_hbox(self.getlevel1, self.getlevel1l, self.getlevel2, self.getlevel2l))) return group_box def create_crop_group(self): group_box = QGroupBox("&Crop") group_box.setCheckable(True) group_box.setChecked(False) self.ignore_crop_l = QtWidgets.QCheckBox('Ignore Crop Image', self) self.crop_msg = QtWidgets.QLabel("Crop Image", self) self.crop_xi = QtWidgets.QLabel("Width: Wi:", self) self.crop_xi.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter) self.getcropxi_l = QtWidgets.QLineEdit(self) self.getcropxi_l.setMaximumWidth(50) self.getcropxi_l.setValidator(QIntValidator(-100, 30)) self.crop_xf = QtWidgets.QLabel("Wf:", self) self.crop_xf.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter) self.getcropxf_l = QtWidgets.QLineEdit(self) self.getcropxf_l.setMaximumWidth(50) self.getcropxf_l.setValidator(QIntValidator(-100, 30)) self.crop_yi = QtWidgets.QLabel("Height: Hi:", self) self.crop_yi.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter) self.getcropyi_l = QtWidgets.QLineEdit(self) self.getcropyi_l.setMaximumWidth(50) self.getcropyi_l.setValidator(QIntValidator(-100, 30)) self.crop_yf = QtWidgets.QLabel("Hf:", self) self.crop_yf.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter) self.getcropyf_l = QtWidgets.QLineEdit(self) self.getcropyf_l.setMaximumWidth(50) self.getcropyf_l.setValidator(QIntValidator(-100, 30)) group_box.setLayout( set_lvbox( set_hbox(self.ignore_crop_l), set_hbox(self.crop_msg), set_hbox(self.crop_xi, self.getcropxi_l, self.crop_xf, self.getcropxf_l), set_hbox(self.crop_yi, self.getcropyi_l, self.crop_yf, self.getcropyf_l))) return group_box def create_type_image_group(self): group_box = QGroupBox("&File to save") group_box.setCheckable(True) group_box.setChecked(True) self.image_png_l = QtWidgets.QCheckBox('Image .png', self) self.image_tif_l = QtWidgets.QCheckBox('Image .tif', self) self.image_fit_l = QtWidgets.QCheckBox('Image .fit', self) group_box.setLayout( set_lvbox(set_hbox(self.image_png_l), set_hbox(self.image_tif_l), set_hbox(self.image_fit_l))) return group_box def create_push_button_group(self): group_box = QGroupBox() self.saveButton = QPushButton("Save") self.saveButton.clicked.connect(self.button_ok_func) self.cancelButton = QPushButton("Cancel") self.cancelButton.clicked.connect(self.func_cancel) self.clearButton = QPushButton("Clear") self.clearButton.clicked.connect(self.clear_all) group_box.setLayout( set_lvbox( set_hbox(self.saveButton, self.clearButton, self.cancelButton))) return group_box def button_ok_func(self): try: y_pixels, x_pixels = self.get_pixels() """ ATENCAO """ # Saving the Settings # if int(self.getcropxi_l.text()) > int(self.getcropxf_l.text()) or \ # int(self.getcropyi_l.text()) > int(self.getcropyf_l.text()) or \ # int(self.getcropxf_l.text()) >= x_pixels or \ # int(self.getcropyf_l.text()) >= y_pixels: # # self.console.raise_text("Wrong values for image crop.", 3) # # else: self.image_settings.set_image_settings( self.getlevel1l.text(), self.getlevel2l.text(), self.getcropxi_l.text(), self.getcropxf_l.text(), self.getcropyi_l.text(), self.getcropyf_l.text(), self.ignore_crop_l.isChecked(), self.image_png_l.isChecked(), self.image_tif_l.isChecked(), self.image_fit_l.isChecked()) self.image_settings.save_settings() self.console.raise_text("Image settings successfully saved!", 1) except Exception as e: print("Image settings were not saved -> {}".format(e)) self.console.raise_text("Image settings were not saved.", 3) def clear_all(self): self.getlevel1l.clear() self.getlevel2l.clear() self.getcropxi_l.clear() self.getcropxf_l.clear() self.getcropyi_l.clear() self.getcropyf_l.clear() def func_cancel(self): self.image_parent.close() def setting_values(self): info = self.get_image_settings() self.set_values(info[0], info[1], info[2], info[3], info[4], info[5], info[6], info[7], info[8], info[9]) def set_values(self, get_level1, get_level2, crop_xi, crop_xf, crop_yi, crop_yf, ignore_crop, image_png, image_tif, image_fit): self.getlevel1l.setText(get_level1) self.getlevel2l.setText(get_level2) self.getcropxi_l.setText(crop_xi) self.getcropxf_l.setText(crop_xf) self.getcropyi_l.setText(crop_yi) self.getcropyf_l.setText(crop_yf) self.ignore_crop_l.setChecked(ignore_crop) self.image_png_l.setChecked(image_png) self.image_tif_l.setChecked(image_tif) self.image_fit_l.setChecked(image_fit)
class SettingsWindow(QtWidgets.QWidget): def __init__(self, parent=None): super(SettingsWindow, self).__init__(parent) self.p = parent self.console = ConsoleThreadOutput() self.site = WidgetsSite(self) self.geo = WidgetsGeography(self) self.sun = WidgetsSun(self) self.button_clear = QtWidgets.QPushButton('Clear', self) self.button_ok = QtWidgets.QPushButton('Save', self) self.button_cancel = QtWidgets.QPushButton('Cancel', self) self.button_settings() # Init Interface self.setting_up() self.refresh_all_fields() def button_settings(self): self.button_clear.clicked.connect(self.clear_all) self.button_cancel.clicked.connect(self.func_cancel) self.button_ok.clicked.connect(self.func_ok) def func_cancel(self): self.p.close() #self.clear_all() def func_ok(self): try: self.save_settings() self.console.raise_text("Project settings successfully saved!", 1) except: self.console.raise_text("Unable to save the project settings.", 3) finally: self.p.close() self.clear_all() self.refresh_all_fields() def clear_all(self): self.site.clear_site() self.geo.clear_geography() self.sun.clear_sun() def refresh_all_fields(self): try: st = ConfigProject() infoSite = st.get_site_settings() self.site.set_site_info(infoSite[0], infoSite[1], infoSite[2]) infoGeo = st.get_geographic_settings() self.geo.set_geography(infoGeo[0], infoGeo[1], infoGeo[2], infoGeo[3], infoGeo[4]) infoSun = st.get_moonsun_settings() self.sun.set_sun(str(infoSun[0]), infoSun[1], str(infoSun[2]), str(infoSun[3])) except Exception as e: print(e) def save_settings(self): try: st = ConfigProject() self.save_site(st) self.save_geo(st) self.save_sun(st) st.save_settings() except Exception as e: print(e) def save_site(self, set): info1 = self.site.get_site_info() set.set_site_settings(info1[0], info1[1], info1[2]) def save_geo(self, set): info2 = self.geo.get_geography() set.set_geographic_settings(info2[0], info2[1], info2[2], info2[3], info2[4]) def save_sun(self, set): info3 = self.sun.get_sun() set.set_moonsun_settings(info3[0], info3[1], info3[2], info3[3]) def setting_up(self): self.setLayout(set_lvbox(set_hbox(self.site), set_hbox(self.geo), set_hbox(self.sun), set_hbox(self.button_ok, self.button_clear, self.button_cancel, stretch2=1)))
class EphemerisShooter(QtCore.QThread): ''' classe para modo automatico ''' signal_started_shooting = QtCore.pyqtSignal(name="signalStartedShooting") signal_temp = QtCore.pyqtSignal(name="signalTemp") def __init__(self): super(EphemerisShooter, self).__init__() self.ObserverFactory = EphemObserverFactory() # self.continuousShooterThread = ContinuousShooterThread(int(info_cam[4])) self.continuousShooterThread = ContinuousShooterThread(0) self.console = ConsoleThreadOutput() self.config = ConfigProject() info = self.config.get_geographic_settings() info_sun = self.config.get_moonsun_settings() self.latitude = info[0] # '-45.51' self.longitude = info[1] # '-23.12' self.elevation = info[2] # 350 self.max_solar_elevation = info_sun[0] # -12 self.ignore_lunar_position = info_sun[1] self.max_lunar_elevation = info_sun[2] # 8 self.max_lunar_phase = info_sun[3] # 1 self.wait_temperature = False self.shootOn = False self.controller = True self.count = 1 def refresh_data(self): try: info = self.config.get_geographic_settings() self.latitude = info[0] # '-45.51' self.longitude = info[1] # '-23.12' self.elevation = info[2] # 350 info_sun = self.config.get_moonsun_settings() self.max_solar_elevation = float(info_sun[0]) # -12 self.ignore_lunar_position = info_sun[1] self.max_lunar_elevation = float(info_sun[2]) # 8 self.max_lunar_phase = float(info_sun[3]) # 1 except Exception as e: self.console.raise_text( "Exception thrown to acquire information\n" "Please set an observatory information on settings\n" + str(e), level=3) self.latitude = 0 self.longitude = 0 self.elevation = 0 self.max_solar_elevation = 0 self.max_lunar_elevation = 0 self.max_lunar_phase = 0 def calculate_moon(self, obs): aux = obs aux.compute_pressure() aux.horizon = '8' moon = ephem.Moon(aux) return aux.previous_setting(moon), aux.next_rising(moon) def calculate_sun(self, obs): aux = obs aux.compute_pressure() aux.horizon = '-12' sun = ephem.Sun(aux) return aux.previous_setting(sun), aux.next_rising(sun) def set_solar_and_lunar_parameters(self, maxSolarElevation, maxLunarElevation, maxLunarPhase): self.max_solar_elevation = maxSolarElevation self.max_lunar_elevation = maxLunarElevation self.max_lunar_phase = maxLunarPhase def run(self): self.refresh_data() obs = self.ObserverFactory.create_observer(longitude=self.longitude, latitude=self.latitude, elevation=self.elevation) self.controller = True self.shootOn = False c = 0 try: while self.controller: obs.date = ephem.date(datetime.datetime.utcnow()) sun = ephem.Sun(obs) moon = ephem.Moon(obs) frac = moon.moon_phase a = ephem.degrees(sun.alt) b = ephem.degrees(str(moon.alt)) # Variavel de controle do shooter t = 0 if float(math.degrees(a)) < self.max_solar_elevation or t == 1: if (not self.ignore_lunar_position and float(math.degrees(b)) < self.max_lunar_elevation and frac < self.max_lunar_phase ) or self.ignore_lunar_position: if not self.shootOn: if not c: self.signal_started_shooting.emit() c = 1 self.signal_temp.emit() time.sleep(5) if self.wait_temperature: # Iniciar as Observações self.start_taking_photo() self.shootOn = True else: if self.shootOn: # Finalizar as Observações self.stop_taking_photo() c = 0 self.t = False self.shootOn = False time.sleep(5) except Exception as e: self.console.raise_text("Exception no Ephemeris Shooter -> " + str(e)) def stop_shooter(self): self.controller = False self.continuousShooterThread.stop_continuous_shooter() def start_taking_photo(self): self.continuousShooterThread.start_continuous_shooter() self.continuousShooterThread.start() def stop_taking_photo(self): self.continuousShooterThread.stop_continuous_shooter()
class FilterWindow(QtWidgets.QWidget): # Cria os campos e espaços no menu filter window def __init__(self, parent=None): super(FilterWindow, self).__init__(parent) self.setField_label_label = None self.setField_wavelength_label = None self.setField_exposure_label = None self.setField_binning_label = None self.setField_1 = None self.setField_label_filter1 = None self.setField_wavelength_filter1 = None self.setField_exposure_filter1 = None self.setField_binning_filter1 = None self.button_ok = None self.button_clear = None self.button_cancel = None self.create_filters_widgets() self.var_save_ini_filters = SettingsFilters() self.f = parent self.console = ConsoleThreadOutput() self.setting_values() self.setLayout( set_lvbox( set_hbox(self.setField_label_label, self.setField_wavelength_label, self.setField_exposure_label, self.setField_binning_label), set_hbox(self.setField_1, self.setField_label_filter1, self.setField_wavelength_filter1, self.setField_exposure_filter1, self.setField_binning_filter1), set_hbox(self.button_ok, self.button_clear, self.button_cancel, stretch2=1))) def get_values(self): return self.var_save_ini_filters.get_filters_settings() def setting_values(self): info = self.get_values() self.set_values(info[0], info[1], info[2], info[3]) def set_values(self, label_filter1, wavelength_filter1, exposure_filter1, binning_filter1): binning_var1 = self.error_binning(binning_filter1) self.setField_label_filter1.setText(label_filter1) self.setField_wavelength_filter1.setText(wavelength_filter1) self.setField_exposure_filter1.setText(exposure_filter1) self.setField_exposure_filter1.setValidator(QIntValidator(0, 360)) self.setField_binning_filter1.setCurrentIndex(binning_var1) def create_filters_widgets(self): self.setField_label_label = QtWidgets.QLabel(" Filter Label", self) self.setField_wavelength_label = QtWidgets.QLabel( " Wavelength (nm)", self) self.setField_exposure_label = QtWidgets.QLabel( " Exposure (s)", self) self.setField_binning_label = QtWidgets.QLabel( " Binning", self) self.setField_1 = QtWidgets.QLabel("1", self) self.setField_label_filter1 = QtWidgets.QLineEdit(self) self.setField_wavelength_filter1 = QtWidgets.QLineEdit(self) self.setField_exposure_filter1 = QtWidgets.QLineEdit(self) self.setField_binning_filter1 = QtWidgets.QComboBox(self) self.setField_binning_filter1.addItem("1x1", 0) self.setField_binning_filter1.addItem("2x2", 1) self.setField_binning_filter1.addItem("3x3", 2) # self.setField_binning_filter1.addItem("4x4", 3) # self.setField_binning_filter1.addItem("5x5", 4) # self.setField_binning_filter1.addItem("6x6", 5) self.button_ok = QtWidgets.QPushButton("Save", self) self.button_ok.clicked.connect(self.button_ok_func) self.button_clear = QtWidgets.QPushButton('Clear', self) self.button_clear.clicked.connect(self.clear_all) self.button_cancel = QtWidgets.QPushButton("Cancel", self) self.button_cancel.clicked.connect(self.func_cancel) def error_binning(self, binning_var): try: binning_filter = int(binning_var) except TypeError: binning_filter = 0 return binning_filter def button_ok_func(self): try: self.var_save_ini_filters.set_filters_settings( self.setField_label_filter1.text(), self.setField_wavelength_filter1.text(), self.setField_exposure_filter1.text(), self.setField_binning_filter1.currentIndex()) self.var_save_ini_filters.save_settings() self.console.raise_text("Filter settings successfully saved!", 1) except Exception as e: self.console.raise_text("Filter settings NOT saved!", 2) print("Filter settings save ERROR -> {}".format(e)) def clear_all(self): self.setField_label_filter1.clear() self.setField_wavelength_filter1.clear() self.setField_exposure_filter1.clear() def func_cancel(self): self.f.close()
class SettingsWindow(QtWidgets.QWidget): def __init__(self, parent=None): super(SettingsWindow, self).__init__(parent) self.cam = SettingsCamera() self.camera = Camera() self.console = ConsoleThreadOutput() #self.a_temp_regulation = TempRegulation(self) self.create_cam_widgets() self.p = parent self.fan = Fan(self.fanButton) #self.button_clear = QtWidgets.QPushButton('Clear', self) self.setField_temperature = QtWidgets.QLineEdit(self) self.setting_values() self.one_photo = SThread() self.setLayout( set_lvbox( set_hbox(self.setField_temperature_label, self.setField_temperature), set_hbox(self.pre, self.prel), set_hbox(self.exp, self.expl), set_hbox(self.binning, self.combo), set_hbox(self.tempo_fotos_label, self.tempo_fotos), set_hbox(self.time_colling_label, self.time_colling), set_hbox(self.dark, self.close_open), set_hbox(self.getlevel1, self.getlevel1l), set_hbox(self.getlevel2, self.getlevel2l), set_hbox(self.btn_one_photo, self.tempButton, self.fanButton, stretch2=1), set_hbox(self.buttonok, self.button_clear, self.buttoncancel, stretch2=1))) def get_camera_settings(self): settings = SettingsCamera() info = settings.get_camera_settings() return info def get_values(self): return self.cam.get_camera_settings() def setting_values(self): info = self.get_values() self.set_values(info[0], info[1], info[2], info[3], info[4], info[5], info[6], info[7], info[8]) def set_values(self, temperature_camera, prefixo, exposicao, binning, tempo_entre_fotos, time_colling, get_level1, get_level2, dark_photo): self.setField_temperature.setText(temperature_camera) self.prel.setText(prefixo) self.expl.setText(exposicao) try: b = int(binning) except: b = 0 try: open_or_close = int(dark_photo) except: open_or_close = 0 self.tempo_fotos.setText(tempo_entre_fotos) self.time_colling.setText(time_colling) self.combo.setCurrentIndex(b) self.close_open.setCurrentIndex(open_or_close) self.getlevel1l.setText(get_level1) self.getlevel2l.setText(get_level2) def create_cam_widgets(self): self.setField_temperature_label = QtWidgets.QLabel( "Temperature(°C):", self) self.pre = QtWidgets.QLabel("Filter name:", self) self.prel = QtWidgets.QLineEdit(self) self.exp = QtWidgets.QLabel("Exposure time(s):", self) self.expl = QtWidgets.QLineEdit(self) self.binning = QtWidgets.QLabel("Binning:", self) self.combo = QtWidgets.QComboBox(self) self.fill_combo() self.dark = QtWidgets.QLabel("Shooter:", self) self.close_open = QtWidgets.QComboBox(self) self.fill_combo_close_open() self.getlevel1 = QtWidgets.QLabel("Image contrast: bottom level:", self) self.getlevel1l = QtWidgets.QLineEdit(self) self.getlevel2 = QtWidgets.QLabel("Image contrast: top level:", self) self.getlevel2l = QtWidgets.QLineEdit(self) self.button_clear = QtWidgets.QPushButton('Clear', self) self.button_clear.clicked.connect(self.clear_all) self.btn_one_photo = QtWidgets.QPushButton('Take Photo', self) self.btn_one_photo.clicked.connect(self.take_one_photo) self.tempButton = QtWidgets.QPushButton("Set Temp", self) self.tempButton.clicked.connect(self.btn_temperature) self.fanButton = QtWidgets.QPushButton("Fan (On/Off)") self.fanButton.clicked.connect(self.button_fan_func) self.buttonok = QtWidgets.QPushButton("Save", self) self.buttonok.clicked.connect(self.button_ok_func) self.buttoncancel = QtWidgets.QPushButton("Cancel", self) self.buttoncancel.clicked.connect(self.func_cancel) self.tempo_fotos_label = QtWidgets.QLabel("Time between photos(s):", self) self.tempo_fotos = QtWidgets.QLineEdit(self) self.time_colling_label = QtWidgets.QLabel("CCD Cooling Time(s):", self) self.time_colling = QtWidgets.QLineEdit(self) def button_ok_func(self): try: # Saving the Settings self.cam.set_camera_settings(self.setField_temperature.text(), self.prel.text(), self.expl.text(),\ self.combo.currentIndex(), self.tempo_fotos.text(), self.time_colling.text(), \ self.getlevel1l.text(), self.getlevel2l.text(), self.close_open.currentIndex()) self.cam.save_settings() self.console.raise_text("Camera settings successfully saved!", 1) except Exception as e: self.console.raise_text("Camera settings were not saved.", 3) finally: pass #self.p.close() def clear_all(self): self.setField_temperature.clear() self.prel.clear() self.expl.clear() self.tempo_fotos.clear() def take_one_photo(self): try: info = self.get_camera_settings() if int(info[6]) == 1: self.console.raise_text("Taking dark photo", 1) self.one_photo.start() else: self.console.raise_text("Taking photo", 1) self.one_photo.start() except Exception: self.console.raise_text("Not possible taking photo", 1) def func_cancel(self): self.p.close() def button_fan_func(self): if getlinkstatus() is True: try: self.fan.set_fan() self.console.raise_text('State changed Fan!', 2) except Exception: self.console.raise_text("The camera is not connected!", 3) self.console.raise_text('State Fan unchanged', 3) else: self.console.raise_text("The camera is not connected!", 3) self.console.raise_text('State Fan unchanged', 3) def fill_combo(self): self.combo.addItem("1x1", 0) self.combo.addItem("2x2", 1) self.combo.addItem("3x3", 2) def fill_combo_close_open(self): self.close_open.addItem("Open", 0) self.close_open.addItem("Close", 1) def btn_temperature(self): try: value = self.setField_temperature.text() if value is '': pass else: self.camera.set_temperature(float(value)) except Exception as e: print("Exception -> {}".format(e))
class SettingsCCDInfos(QWidget): def __init__(self, parent=None): super(SettingsCCDInfos, self).__init__(parent) # Instance attributes create_ccd_info_group self.p = parent self.info_port_ccd_l = None self.info_port_ccd_f = None self.info_camera_model_l = None self.info_camera_model_f = None self.info_pixel_array_l = None self.info_pixel_array_f = None # Instance attributes create_ccd_camera_group self.close_open = None self.temp_set_point_l = None self.temp_set_point_f = None self.temp_init_l = None self.temp_init_f = None self.time_between_photos_l = None self.time_between_photos_f = None self.one_photoButton = None self.tempButton = None self.fanButton = None # Instance attributes create_push_button_group self.saveButton = None self.cancelButton = None self.clearButton = None self.imager_window = parent self.cam = Camera() self.var_save_ini_camera = SettingsCamera() self.console = ConsoleThreadOutput() self.fan = Fan(self.fanButton) self.one_photo = SThread() self.lock = Locker() self.firmware = "????" self.model = "????" self.y_pixels = "????" self.x_pixels = "????" grid = QGridLayout() # Additional Parameters (Apparently Useless) 0, 1 | 1, 1 | 2, 1 grid.addWidget(self.create_ccd_info_group()) grid.addWidget(self.create_ccd_camera_group()) grid.addWidget(self.create_push_button_group()) self.setLayout(grid) self.w = grid.geometry().width() self.h = grid.geometry().height() self.setWindowTitle("Imager Box") # self.resize(500, 340) # self.info_cam() def create_ccd_info_group(self): group_box = QGroupBox("Info CCD") ''' self.info_port_ccd_l = QtWidgets.QLabel("Camera Firmware: ", self) self.info_port_ccd_l.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter) self.info_port_ccd_f = QtWidgets.QLabel(self.firmware) self.info_port_ccd_f.setAlignment(QtCore.Qt.AlignLeft | QtCore.Qt.AlignVCenter) ''' self.info_camera_model_l = QtWidgets.QLabel("Camera Model: ", self) self.info_camera_model_l.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter) self.info_camera_model_f = QtWidgets.QLabel(self.model) self.info_camera_model_f.setAlignment(QtCore.Qt.AlignLeft | QtCore.Qt.AlignVCenter) self.info_pixel_array_l = QtWidgets.QLabel("Pixel array: ", self) self.info_pixel_array_l.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter) self.info_pixel_array_f = QtWidgets.QLabel(self.x_pixels + " X " + self.y_pixels + " Pixels") self.info_pixel_array_f.setAlignment(QtCore.Qt.AlignLeft | QtCore.Qt.AlignVCenter) group_box.setLayout( set_lvbox( set_hbox(self.info_camera_model_l, self.info_camera_model_f), set_hbox(self.info_pixel_array_l, self.info_pixel_array_f))) return group_box def create_ccd_camera_group(self): group_box = QGroupBox("Settings") group_box.setCheckable(True) group_box.setChecked(False) self.shutter_l = QtWidgets.QLabel("Shutter:", self) self.shutter_l.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter) self.close_open = QtWidgets.QLabel("Closed") self.close_open.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter) self.temp_set_point_l = QtWidgets.QLabel("CCD Temp Set Point (°C):", self) self.temp_set_point_l.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter) self.temp_set_point_f = QtWidgets.QLineEdit(self) self.temp_set_point_f.setMaximumWidth(100) self.temp_set_point_f.setValidator(QIntValidator(-100, 30)) self.temp_init_l = QtWidgets.QLabel("CCD Cooling Time(s):", self) self.temp_init_l.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter) self.temp_init_f = QtWidgets.QLineEdit(self) self.temp_init_f.setMaximumWidth(100) self.temp_init_f.setValidator(QIntValidator(0, 600)) self.time_between_photos_l = QtWidgets.QLabel( "Time Between Images(s):", self) self.time_between_photos_l.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter) self.time_between_photos_f = QtWidgets.QLineEdit(self) self.time_between_photos_f.setMaximumWidth(100) # self.time_between_photos_f.setValidator(QIntValidator(0, 600)) self.one_photoButton = QtWidgets.QPushButton('Take Photo', self) self.one_photoButton.clicked.connect(self.take_one_photo) self.tempButton = QtWidgets.QPushButton("Set Temp", self) self.tempButton.clicked.connect(self.btn_temperature) self.fanButton = QtWidgets.QPushButton("Fan (On/Off)") self.fanButton.clicked.connect(self.button_fan_func) self.setting_values() group_box.setLayout( set_lvbox( set_hbox(self.shutter_l, self.close_open), set_hbox(self.temp_set_point_l, self.temp_set_point_f), set_hbox(self.temp_init_l, self.temp_init_f), set_hbox(self.time_between_photos_l, self.time_between_photos_f), set_hbox(self.one_photoButton, self.tempButton, self.fanButton, stretch2=1))) return group_box def create_push_button_group(self): group_box = QGroupBox("&Push Buttons") # group_box.setCheckable(True) # group_box.setChecked(True) self.saveButton = QPushButton("Save") self.saveButton.clicked.connect(self.button_ok_func) self.cancelButton = QPushButton("Cancel") self.cancelButton.clicked.connect(self.func_cancel) self.clearButton = QPushButton("Clear") self.clearButton.clicked.connect(self.clear_all) group_box.setLayout( set_lvbox( set_hbox(self.saveButton, self.clearButton, self.cancelButton))) return group_box def get_values(self): return self.var_save_ini_camera.get_camera_settings() def setting_values(self): info = self.get_values() self.set_values(info[0], info[5], info[4]) def set_values(self, temperature_camera, temp_init_f, tbf): self.temp_set_point_f.setText(temperature_camera) self.temp_init_f.setText(temp_init_f) self.time_between_photos_f.setText(tbf) def button_ok_func(self): try: self.var_save_ini_camera.set_camera_settings( self.temp_set_point_f.text(), self.temp_init_f.text(), self.time_between_photos_f.text()) self.var_save_ini_camera.save_settings() self.console.raise_text("Camera settings successfully saved!", 1) except Exception as e: print(e) finally: self.p.close() self.clear_all() self.setting_values() # self.refresh_all_fields() def clear_all(self): self.temp_set_point_f.clear() self.temp_init_f.clear() def func_cancel(self): self.imager_window.close() def take_one_photo(self): try: if str(self.close_open) == "Closed": # self.console.raise_text("take_one_photo started: dark photo", 1) # time.sleep(1) self.cam.one_photo = True print("bbbbbbbbbbbbbbbbbbbbb") print(self.cam.one_photo) self.cam.start_one_photo() # self.one_photo.args_one_photo(self.select_filter_manual, self.select_filter_shutter) # self.one_photo.start() else: # self.console.raise_text("take_one_photo started: photo", 1) # time.sleep(1) self.cam.one_photo = True print("aaaaaaaaaaaaa") print(self.cam.one_photo) self.cam.start_one_photo() except Exception as e: self.console.raise_text( "Not possible taking photo -> {}".format(e), 1) finally: self.cam.one_photo = False def button_fan_func(self): if getlinkstatus() is True: try: self.fan.set_fan() self.console.raise_text('State changed Fan!', 2) except Exception as e: self.console.raise_text("The camera is not connected!", 3) self.console.raise_text('State Fan unchanged', 3) self.console.raise_text("Exception -> {}".format(e)) else: self.console.raise_text("The camera is not connected!", 3) self.console.raise_text('State Fan unchanged', 3) def btn_temperature(self): try: value = self.temp_set_point_f.text() if value is '': pass else: try: self.cam.set_temperature(float(value)) except TypeError: self.cam.set_temperature(float(15.0)) except Exception as e: print("Exception -> {}".format(e)) def info_cam(self): # self.firmware, try: if self.cam.is_connected: self.model = self.cam.get_firmware_and_model_and_pixels()[1] self.x_pixels, self.y_pixels = self.cam.pass_list_str # self.model, self.x_pixels, self.y_pixels = self.cam.get_model_and_pixels_new() placeholder = None else: self.model, self.x_pixels, self.y_pixels = "????", "????", "????" # self.info_port_ccd_f.setText(self.firmware) self.info_camera_model_f.setText(self.model) self.info_pixel_array_f.setText( str(self.y_pixels) + " x " + str(self.x_pixels)) placeholder = None except Exception as e: print("CCDInfos get_firmware_and_model_and_pixels -> {}".format(e)) self.model, self.x_pixels, self.y_pixels = "????", "????", "????"
class ContinuousShooterThread(QtCore.QThread): ''' classe para modo manual ''' signalAfterShooting = QtCore.pyqtSignal(name="signalAfterShooting") signal_temp = QtCore.pyqtSignal(name="signalTemp") def __init__(self, timeSleep): super(ContinuousShooterThread, self).__init__() self.continuous = True self.s = timeSleep ''' SThread manda para o Sbigdriver as informações para se tirar a foto em si. ''' self.ss = SThread() self.ss.started.connect(self.thread_iniciada) self.console = ConsoleThreadOutput() self.count = 0 self.wait_temperature = False self.not_two_dark = True self.one_photo = False def set_sleep_time(self, t): self.s = t def run(self): self.count = 1 while self.continuous: try: self.signal_temp.emit() if self.wait_temperature: self.ss.start() while self.ss.isRunning(): time.sleep(1) except Exception as e: print(e) time.sleep(self.s) self.signalAfterShooting.emit() def start_continuous_shooter(self): if not self.one_photo: self.shutter_control(True) self.continuous = True def stop_continuous_shooter(self): self.wait_temperature = False self.continuous = False self.not_two_dark = False self.console.raise_text("Taking dark photo", 1) self.shutter_control(False) self.ss.take_dark() time.sleep(1) self.count = 1 # Consertar Shutter Para o onePhoto def stop_one_photo(self): self.one_photo = False self.wait_temperature = False self.continuous = False self.count = 1 def thread_iniciada(self): if self.one_photo: self.console.raise_text("Taking photo", 1) self.stop_one_photo() elif self.count == 1 and not self.one_photo: self.console.raise_text("Taking dark photo", 1) self.ss.take_dark() self.count += 1 self.not_two_dark = False elif self.count != 1 and not self.one_photo: self.console.raise_text("Taking photo N: {}".format(self.count), 1) self.count += 1 def shutter_control(self, cont): try: ser = serial.Serial(serial_ports()[len(serial_ports()) - 1], 9600, bytesize=serial.EIGHTBITS, parity=serial.PARITY_NONE, stopbits=serial.STOPBITS_ONE) if cont is True: self.console.raise_text("Opening Shutter", 1) send = bytes([235, 144, 86, 1, 46]) ser.write(send) # time.sleep(15) else: self.console.raise_text("Closing Shutter", 1) send = bytes([235, 144, 214, 1, 174]) ser.write(send) # time.sleep(15) except Exception: self.console.raise_text("No Serial Equipment!", 3)
class SettingsWindow(QtWidgets.QWidget): ''' Cria os campos e espaços no menu settings window ''' def __init__(self, parent=None): super(SettingsWindow, self).__init__(parent) self.cam = SettingsCamera() self.camera = Camera() self.console = ConsoleThreadOutput() self.create_cam_widgets() self.p = parent self.fan = Fan(self.fanButton) self.lock = Locker() self.setting_values() self.one_photo = SThread() self.setLayout( set_lvbox( set_hbox(self.setField_temperature_label, self.setField_temperature), set_hbox(self.pre, self.prel), set_hbox(self.exp, self.expl), set_hbox(self.binning, self.combo), set_hbox(self.dark, self.close_open), set_hbox(self.tempo_fotos_label, self.tempo_fotos), set_hbox(self.time_colling_label, self.time_colling), set_hbox(self.contrast_msg), set_hbox(self.getlevel1, self.getlevel1l, self.getlevel2, self.getlevel2l), set_hbox(self.ignore_crop_l), set_hbox(self.crop_msg), set_hbox(self.crop_xi, self.getcropxi_l, self.crop_xf, self.getcropxf_l), set_hbox(self.crop_yi, self.getcropyi_l, self.crop_yf, self.getcropyf_l), set_hbox(self.image_tif_l), set_hbox(self.image_fit_l), set_hbox(self.btn_one_photo, self.tempButton, self.fanButton, stretch2=1), set_hbox(self.buttonok, self.button_clear, self.buttoncancel, stretch2=1))) def get_camera_settings(self): settings = SettingsCamera() info = settings.get_camera_settings() return info def get_pixels(self): info = self.get_info_pixels() return int(info[-2]), int(info[-1]) def get_info_pixels(self): ''' Function to get the CCD Info This function will return [Pixels] ''' ret = None self.lock.set_acquire() try: ret = tuple(ccdinfo()) except Exception as e: self.console.raise_text( "Failed to get camera information.\n{}".format(e)) finally: self.lock.set_release() return ret def get_values(self): return self.cam.get_camera_settings() def setting_values(self): info = self.get_values() self.set_values(info[0], info[1], info[2], info[3], info[4], info[5], info[6], info[7], info[8], info[9],\ info[10], info[11], info[12], info[13], info[14], info[15]) def set_values(self, temperature_camera, prefixo, exposicao, binning, tempo_entre_fotos, time_colling, get_level1,\ get_level2, dark_photo, crop_xi, crop_xf, crop_yi, crop_yf, ignore_crop, image_tif, image_fit): self.setField_temperature.setText(temperature_camera) self.prel.setText(prefixo) self.expl.setText(exposicao) try: b = int(binning) except: b = 0 try: open_or_close = int(dark_photo) except: open_or_close = 0 self.tempo_fotos.setText(tempo_entre_fotos) self.time_colling.setText(time_colling) self.combo.setCurrentIndex(b) self.close_open.setCurrentIndex(open_or_close) self.getlevel1l.setText(get_level1) self.getlevel2l.setText(get_level2) self.getcropxi_l.setText(crop_xi) self.getcropxf_l.setText(crop_xf) self.getcropyi_l.setText(crop_yi) self.getcropyf_l.setText(crop_yf) self.ignore_crop_l.setChecked(ignore_crop) self.image_tif_l.setChecked(image_tif) self.image_fit_l.setChecked(image_fit) def create_cam_widgets(self): self.setField_temperature_label = QtWidgets.QLabel( "CCD Temperature(°C):", self) self.setField_temperature_label.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter) self.setField_temperature = QtWidgets.QLineEdit(self) self.setField_temperature.setMaximumWidth(100) self.pre = QtWidgets.QLabel("Filter Name:", self) self.pre.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter) self.prel = QtWidgets.QLineEdit(self) self.prel.setMaximumWidth(100) self.exp = QtWidgets.QLabel("Exposure time (s):", self) self.exp.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter) self.expl = QtWidgets.QLineEdit(self) self.expl.setMaximumWidth(100) self.binning = QtWidgets.QLabel("Binning:", self) self.binning.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter) self.combo = QtWidgets.QComboBox(self) self.combo.setMaximumWidth(100) self.fill_combo() self.dark = QtWidgets.QLabel("Shutter:", self) self.dark.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter) self.close_open = QtWidgets.QComboBox(self) self.close_open.setMaximumWidth(100) self.fill_combo_close_open() self.tempo_fotos_label = QtWidgets.QLabel("Time Between Images (s):", self) self.tempo_fotos_label.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter) self.tempo_fotos = QtWidgets.QLineEdit(self) self.tempo_fotos.setMaximumWidth(100) self.time_colling_label = QtWidgets.QLabel("CCD Cooling Time (s):", self) self.time_colling_label.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter) self.time_colling = QtWidgets.QLineEdit(self) self.time_colling.setMaximumWidth(100) self.contrast_msg = QtWidgets.QLabel("Image Contrast:", self) self.getlevel1 = QtWidgets.QLabel("Bottom Level:", self) self.getlevel1.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter) self.getlevel1l = QtWidgets.QLineEdit(self) self.getlevel1l.setMaximumWidth(50) self.getlevel2 = QtWidgets.QLabel("Top Level:", self) self.getlevel2.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter) self.getlevel2l = QtWidgets.QLineEdit(self) self.getlevel2l.setMaximumWidth(50) self.ignore_crop_l = QtWidgets.QCheckBox('Ignore Crop Image', self) self.crop_msg = QtWidgets.QLabel("Crop Image", self) self.crop_xi = QtWidgets.QLabel("Width: Wi:", self) self.crop_xi.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter) self.getcropxi_l = QtWidgets.QLineEdit(self) self.getcropxi_l.setMaximumWidth(50) self.crop_xf = QtWidgets.QLabel("Wf:", self) self.crop_xf.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter) self.getcropxf_l = QtWidgets.QLineEdit(self) self.getcropxf_l.setMaximumWidth(50) self.crop_yi = QtWidgets.QLabel("Height: Hi:", self) self.crop_yi.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter) self.getcropyi_l = QtWidgets.QLineEdit(self) self.getcropyi_l.setMaximumWidth(50) self.crop_yf = QtWidgets.QLabel("Hf:", self) self.crop_yf.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter) self.getcropyf_l = QtWidgets.QLineEdit(self) self.getcropyf_l.setMaximumWidth(50) self.image_tif_l = QtWidgets.QCheckBox('Image .tif', self) self.image_fit_l = QtWidgets.QCheckBox('Image .fit', self) self.button_clear = QtWidgets.QPushButton('Clear', self) self.button_clear.clicked.connect(self.clear_all) self.btn_one_photo = QtWidgets.QPushButton('Take Photo', self) self.btn_one_photo.clicked.connect(self.camera.start_one_photo) self.tempButton = QtWidgets.QPushButton("Set Temp", self) self.tempButton.clicked.connect(self.btn_temperature) self.fanButton = QtWidgets.QPushButton("Fan (On/Off)") self.fanButton.clicked.connect(self.button_fan_func) self.buttonok = QtWidgets.QPushButton("Save", self) self.buttonok.clicked.connect(self.button_ok_func) self.buttoncancel = QtWidgets.QPushButton("Cancel", self) self.buttoncancel.clicked.connect(self.func_cancel) def button_ok_func(self): try: y_pixels, x_pixels = self.get_pixels() # Saving the Settings if int(self.getcropxi_l.text()) > int(self.getcropxf_l.text()) or\ int(self.getcropyi_l.text()) > int(self.getcropyf_l.text()) or\ int(self.getcropxf_l.text()) >= x_pixels/(int(self.combo.currentIndex() + 1)) or \ int(self.getcropyf_l.text()) >= y_pixels/(int(self.combo.currentIndex() + 1)): self.console.raise_text("Wrong values for image crop.", 3) else: self.cam.set_camera_settings(self.setField_temperature.text(), self.time_colling.text(), self.tempo_fotos.text()) self.cam.save_settings() self.console.raise_text("Camera settings successfully saved!", 1) """ self.setField_temperature.text(), self.prel.text(), self.expl.text(), self.combo.currentIndex(), self.tempo_fotos.text(), self.time_colling.text(), self.getlevel1l.text(), self.getlevel2l.text(), self.close_open.currentIndex(), self.getcropxi_l.text(), self.getcropxf_l.text(), self.getcropyi_l.text(), self.getcropyf_l.text(), self.ignore_crop_l.isChecked(), self.image_tif_l.isChecked(), self.image_fit_l.isChecked() """ except Exception as e: self.console.raise_text("Camera settings were not saved.", 3) def clear_all(self): self.setField_temperature.clear() self.prel.clear() self.expl.clear() self.tempo_fotos.clear() def take_one_photo(self): try: info = self.get_camera_settings() if int(info[8]) == 1: self.console.raise_text("Taking dark photo", 1) self.one_photo.start() else: self.console.raise_text("Taking photo", 1) self.one_photo.start() except Exception: self.console.raise_text("Not possible taking photo", 1) def func_cancel(self): self.p.close() def button_fan_func(self): if getlinkstatus() is True: try: self.fan.set_fan() self.console.raise_text('State changed Fan!', 2) except Exception: self.console.raise_text("The camera is not connected!", 3) self.console.raise_text('State Fan unchanged', 3) else: self.console.raise_text("The camera is not connected!", 3) self.console.raise_text('State Fan unchanged', 3) def fill_combo(self): self.combo.addItem("1x1", 0) self.combo.addItem("2x2", 1) self.combo.addItem("3x3", 2) def fill_combo_close_open(self): self.close_open.addItem("Open", 0) self.close_open.addItem("Close", 1) def btn_temperature(self): try: value = self.setField_temperature.text() if value is '': pass else: self.camera.set_temperature(float(value)) except Exception as e: print("Exception -> {}".format(e))
class SettingsCCDInfos(QWidget): def __init__(self, parent=None): super(SettingsCCDInfos, self).__init__(parent) # Instance attributes create_filter_wheel_info_group self.serial_filter_wheel_info_l = None self.serial_filter_wheel_info_f = None self.tempt_filter_wheel_info_l = None self.tempt_filter_wheel_info_f = None self.slots_filter_wheel_info_l = None self.slots_filter_wheel_info_f = None # Instance attributes create_filter_wheel_group self.shutter_l = None self.close_open_filter_wheel = None self.close_open_filter_wheel_info = None self.btn_set_shutter = None self.get_filter_l = None self.filter_position = None self.btn_set_filter = None self.set_filter_position = None self.btn_home_position_filter = None # Instance attributes create_ccd_info_group self.info_port_ccd_l = None self.info_port_ccd_f = None self.info_camera_model_l = None self.info_camera_model_f = None self.info_pixel_array_l = None self.info_pixel_array_f = None # Instance attributes create_ccd_camera_group self.close_open = None self.temp_set_point_l = None self.temp_set_point_f = None self.temp_init_l = None self.temp_init_f = None self.one_photoButton = None self.tempButton = None self.fanButton = None # Instance attributes create_push_button_group self.saveButton = None self.cancelButton = None self.clearButton = None self.select_filter_manual = 1 self.select_filter_shutter = "Closed" self.imager_window = parent self.cam = Camera() self.roda_filtros = FilterControl() self.var_save_ini_camera = SettingsCamera() self.console = ConsoleThreadOutput() self.fan = Fan(self.fanButton) self.one_photo = SThread() self.lock = Locker() self.firmware = "????" self.model = "????" self.y_pixels = "????" self.x_pixels = "????" grid = QGridLayout() grid.addWidget(self.create_filter_wheel_info_group(), 0, 0) grid.addWidget(self.create_filter_wheel_group(), 1, 0) grid.addWidget(self.create_ccd_info_group(), 0, 1) grid.addWidget(self.create_ccd_camera_group(), 1, 1) grid.addWidget(self.create_push_button_group(), 2, 1) self.setLayout(grid) self.button_settings() self.setWindowTitle("Imager Box") self.resize(500, 340) self.info_cam() def create_filter_wheel_info_group(self): group_box = QGroupBox("&Filter Wheel Info") self.serial_filter_wheel_info_l = QtWidgets.QLabel("Serial Port: ", self) self.serial_filter_wheel_info_l.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter) try: motor_door_aux = str(self.roda_filtros.motor_door) except Exception as e: print(e) motor_door_aux = "???" self.serial_filter_wheel_info_f = QtWidgets.QLabel(motor_door_aux, self) self.serial_filter_wheel_info_f.setAlignment(QtCore.Qt.AlignLeft | QtCore.Qt.AlignVCenter) self.slots_filter_wheel_info_l = QtWidgets.QLabel("Filter Slot: ", self) self.slots_filter_wheel_info_l.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter) self.slots_filter_wheel_info_f = QtWidgets.QLabel("6", self) self.slots_filter_wheel_info_f.setAlignment(QtCore.Qt.AlignLeft | QtCore.Qt.AlignVCenter) self.tempt_filter_wheel_info_l = QtWidgets.QLabel("Filter Temperature: ", self) self.tempt_filter_wheel_info_l.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter) self.tempt_filter_wheel_info_f = QtWidgets.QLabel("25 °C", self) self.tempt_filter_wheel_info_f.setAlignment(QtCore.Qt.AlignLeft | QtCore.Qt.AlignVCenter) group_box.setLayout(set_lvbox(set_hbox(self.serial_filter_wheel_info_l, self.serial_filter_wheel_info_f), set_hbox(self.slots_filter_wheel_info_l, self.slots_filter_wheel_info_f), set_hbox(self.tempt_filter_wheel_info_l, self.tempt_filter_wheel_info_f))) return group_box def create_filter_wheel_group(self): group_box = QGroupBox("&Filter Wheel Control") group_box.setCheckable(True) group_box.setChecked(False) self.shutter_l = QtWidgets.QLabel("Shutter status:", self) self.shutter_l.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter) self.close_open_filter_wheel_info = QtWidgets.QLabel("Closed") self.close_open_filter_wheel_info.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter) self.btn_set_shutter = QtWidgets.QPushButton('Set shutter', self) self.close_open_filter_wheel = QtWidgets.QComboBox(self) self.close_open_filter_wheel.setMaximumWidth(100) self.fill_combo_close_open_filter_wheel_shutter() filter_position = self.roda_filtros.get_current_filter() if filter_position == "None": filter_position = "1" self.get_filter_l = QtWidgets.QLabel('Current filter:', self) self.filter_position = QtWidgets.QLabel(filter_position) self.filter_position.setAlignment(QtCore.Qt.AlignLeft | QtCore.Qt.AlignVCenter) self.filter_position.setMinimumWidth(60) self.btn_set_filter = QtWidgets.QPushButton('Set filter', self) self.set_filter_position = QtWidgets.QComboBox(self) self.set_filter_position.setMaximumWidth(100) self.fill_combo_filter_position() self.btn_home_position_filter = QtWidgets.QPushButton('Home Reset', self) group_box.setLayout(set_lvbox(set_hbox(self.shutter_l, self.close_open_filter_wheel_info), set_hbox(self.btn_set_shutter, self.close_open_filter_wheel), set_hbox(self.get_filter_l, self.filter_position, stretch2=1), set_hbox(self.btn_set_filter, self.set_filter_position), set_hbox(self.btn_home_position_filter))) return group_box def create_ccd_info_group(self): group_box = QGroupBox("Info CCD") self.info_port_ccd_l = QtWidgets.QLabel("Camera Firmware: ", self) self.info_port_ccd_l.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter) self.info_port_ccd_f = QtWidgets.QLabel(self.firmware) self.info_port_ccd_f.setAlignment(QtCore.Qt.AlignLeft | QtCore.Qt.AlignVCenter) self.info_camera_model_l = QtWidgets.QLabel("Camera Model: ", self) self.info_camera_model_l.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter) self.info_camera_model_f = QtWidgets.QLabel(self.model) self.info_camera_model_f.setAlignment(QtCore.Qt.AlignLeft | QtCore.Qt.AlignVCenter) self.info_pixel_array_l = QtWidgets.QLabel("Pixel array: ", self) self.info_pixel_array_l.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter) self.info_pixel_array_f = QtWidgets.QLabel(self.x_pixels + " X " + self.y_pixels + " Pixels") self.info_pixel_array_f.setAlignment(QtCore.Qt.AlignLeft | QtCore.Qt.AlignVCenter) group_box.setLayout(set_lvbox(set_hbox(self.info_port_ccd_l, self.info_port_ccd_f), set_hbox(self.info_camera_model_l, self.info_camera_model_f), set_hbox(self.info_pixel_array_l, self.info_pixel_array_f))) return group_box def create_ccd_camera_group(self): group_box = QGroupBox("Settings") group_box.setCheckable(True) group_box.setChecked(False) self.shutter_l = QtWidgets.QLabel("Shutter:", self) self.shutter_l.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter) self.close_open = QtWidgets.QLabel("Closed") self.close_open.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter) self.temp_set_point_l = QtWidgets.QLabel("CCD Temp Set Point (°C):", self) self.temp_set_point_l.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter) self.temp_set_point_f = QtWidgets.QLineEdit(self) self.temp_set_point_f.setMaximumWidth(100) self.temp_set_point_f.setValidator(QIntValidator(-100, 30)) self.temp_init_l = QtWidgets.QLabel("Tempo para iniciar(s):", self) self.temp_init_l.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter) self.temp_init_f = QtWidgets.QLineEdit(self) self.temp_init_f.setMaximumWidth(100) self.temp_init_f.setValidator(QIntValidator(0, 600)) self.one_photoButton = QtWidgets.QPushButton('Take Photo', self) self.one_photoButton.clicked.connect(self.take_one_photo) self.tempButton = QtWidgets.QPushButton("Set Temp", self) self.tempButton.clicked.connect(self.btn_temperature) self.fanButton = QtWidgets.QPushButton("Fan (On/Off)") self.fanButton.clicked.connect(self.button_fan_func) self.setting_values() group_box.setLayout(set_lvbox(set_hbox(self.shutter_l, self.close_open), set_hbox(self.temp_set_point_l, self.temp_set_point_f), set_hbox(self.temp_init_l, self.temp_init_f), set_hbox(self.one_photoButton, self.tempButton, self.fanButton, stretch2=1))) return group_box def create_push_button_group(self): group_box = QGroupBox("&Push Buttons") # group_box.setCheckable(True) # group_box.setChecked(True) self.saveButton = QPushButton("Save") self.saveButton.clicked.connect(self.button_ok_func) self.cancelButton = QPushButton("Cancel") self.cancelButton.clicked.connect(self.func_cancel) self.clearButton = QPushButton("Clear") self.clearButton.clicked.connect(self.clear_all) group_box.setLayout(set_lvbox(set_hbox(self.saveButton, self.clearButton, self.cancelButton))) return group_box def get_info_pixels(self): # Function to get the CCD Info # This function will return [Pixels] ret = None self.lock.set_acquire() try: ret = tuple(ccdinfo()) except Exception as e: self.console.raise_text("Failed to get camera information.\n{}".format(e)) finally: self.lock.set_release() return ret def fill_combo_close_open_filter_wheel_shutter(self): self.close_open_filter_wheel.addItem("Closed", 2) self.close_open_filter_wheel.addItem("Opened", 1) def func_close_open_shutter(self): my_slot_close_open_shutter = self.close_open_filter_wheel.currentIndex() if my_slot_close_open_shutter == 0: self.roda_filtros.close_shutter() self.select_filter_shutter = "Closed" self.console.raise_text("Shutter Filter Wheel Closed", 1) self.close_open.setText("Closed") self.close_open_filter_wheel_info.setText("Closed") else: self.roda_filtros.open_shutter() self.select_filter_shutter = "Opened" self.console.raise_text("Shutter Filter Wheel Opened ", 1) self.close_open.setText("Opened") self.close_open_filter_wheel_info.setText("Opened") def fill_combo_filter_position(self): self.set_filter_position.addItem("1", 1) self.set_filter_position.addItem("2", 2) self.set_filter_position.addItem("3", 3) self.set_filter_position.addItem("4", 4) self.set_filter_position.addItem("5", 5) self.set_filter_position.addItem("6", 6) def func_filter_position(self): available_filters_list_and_commons = get_filter_settings() available_filters_list_and_commons = list(available_filters_list_and_commons) permited_filters = '' for x in available_filters_list_and_commons: permited_filters += str(x) try: if self.roda_filtros.connect_state: sleep(1) wish_filter_int = self.set_filter_position.currentIndex() + 1 aux = 1 for x in permited_filters: if int(wish_filter_int) == int(x): aux = 0 if aux == 0: self.roda_filtros.filter_wheel_control(int(wish_filter_int)) else: self.console.raise_text("There is no filter on slot number " + str(wish_filter_int) + "!", 3) self.console.raise_text("Please include a new filter on the Filters Settings Menu!", 3) sleep(1) except Exception as e: print("def func_filter_position(self): -> " + str(e)) finally: if aux == 0: if self.roda_filtros.connect_state: self.select_filter_manual = wish_filter_int self.filter_position.setText(str(wish_filter_int)) self.console.raise_text("Filter Position: {}".format(str(wish_filter_int)), 2) else: self.filter_position.setText("?") self.console.raise_text("Filter Wheel is not connect!", 3) def button_settings(self): self.btn_set_shutter.clicked.connect(self.func_close_open_shutter) self.btn_set_filter.clicked.connect(self.func_filter_position) self.btn_home_position_filter.clicked.connect(self.func_home_position) def func_home_position(self): try: if self.roda_filtros.connect_state: sleep(0.5) print("Home Position") self.roda_filtros.home_reset() sleep(1) except Exception as e: print(e) finally: if self.roda_filtros.connect_state: self.filter_position.setText("1") self.console.raise_text("Filter Position: 1", 2) self.console.raise_text("Shutter Filter Wheel Closed", 1) self.close_open.setText("Closed") self.close_open_filter_wheel_info.setText("Closed") else: self.filter_position.setText("?") self.console.raise_text("Filter Wheel is not connect!", 3) def get_values(self): return self.var_save_ini_camera.get_camera_settings() def setting_values(self): info = self.get_values() self.set_values(info[0], info[1]) def set_values(self, temperature_camera, temp_init_f): self.temp_set_point_f.setText(temperature_camera) self.temp_init_f.setText(temp_init_f) def button_ok_func(self): try: self.var_save_ini_camera.set_camera_settings(self.temp_set_point_f.text(), self.temp_init_f.text()) self.var_save_ini_camera.save_settings() self.console.raise_text("Camera settings successfully saved!", 1) except Exception as e: print(e) def clear_all(self): self.temp_set_point_f.clear() self.temp_init_f.clear() def func_cancel(self): self.imager_window.close() def take_one_photo(self): try: if self.select_filter_shutter == "Closed": self.console.raise_text("AQUI dark photo", 1) self.cam.start_one_photo(self.select_filter_manual, self.select_filter_shutter) # self.one_photo.args_one_photo(self.select_filter_manual, self.select_filter_shutter) # self.one_photo.start() else: self.console.raise_text("AQUI photo", 1) self.cam.start_one_photo(self.select_filter_manual, self.select_filter_shutter) except Exception as e: self.console.raise_text("Not possible taking photo -> {}".format(e), 1) def button_fan_func(self): if getlinkstatus() is True: try: self.fan.set_fan() self.console.raise_text('State changed Fan!', 2) except Exception as e: self.console.raise_text("The camera is not connected!", 3) self.console.raise_text('State Fan unchanged', 3) self.console.raise_text("Exception -> {}".format(e)) else: self.console.raise_text("The camera is not connected!", 3) self.console.raise_text('State Fan unchanged', 3) def btn_temperature(self): try: value = self.temp_set_point_f.text() if value is '': pass else: try: self.cam.set_temperature(float(value)) except TypeError: self.cam.set_temperature(float(20.0)) except Exception as e: print("Exception -> {}".format(e)) def info_cam(self): try: if getlinkstatus() is True: self.firmware, self.model, self.y_pixels, self.x_pixels = \ self.cam.get_firmware_and_model_and_pixels() else: self.firmware, self.model, self.y_pixels, self.x_pixels = "????", "????", \ "????", "????" self.info_port_ccd_f.setText(self.firmware) self.info_camera_model_f.setText(self.model) self.info_pixel_array_f.setText(str(self.y_pixels) + " x " + str(self.x_pixels)) except Exception as e: print("CCDInfos get_firmware_and_model_and_pixels -> {}".format(e)) self.firmware, self.model, self.y_pixels, self.x_pixels = "????", "????", \ "????", "????"
class SettingsWindow(QtWidgets.QWidget): def __init__(self, parent=None): super(SettingsWindow, self).__init__(parent) self.p = parent self.console = ConsoleThreadOutput() self.site = WidgetsSite(self) self.geo = WidgetsGeography(self) self.sun = WidgetsSun(self) self.button_clear = QtWidgets.QPushButton('Clear', self) self.button_ok = QtWidgets.QPushButton('Save', self) self.button_cancel = QtWidgets.QPushButton('Cancel', self) self.button_settings() # Init Interface # self.setting_up() self.grid = self.setting_up() self.w = self.grid.geometry().width() self.h = self.grid.geometry().height() self.refresh_all_fields() def button_settings(self): self.button_clear.clicked.connect(self.clear_all) self.button_cancel.clicked.connect(self.func_cancel) self.button_ok.clicked.connect(self.func_ok) def func_cancel(self): self.p.close() #self.clear_all() def func_ok(self): try: self.save_settings() su.UPDATER += 1 self.console.raise_text("Project settings successfully saved!", 1) except: self.console.raise_text("Unable to save the project settings.", 3) finally: self.p.close() self.clear_all() self.refresh_all_fields() def clear_all(self): self.site.clear_site() self.geo.clear_geography() self.sun.clear_sun() def refresh_all_fields(self): try: st = ConfigProject() infoSite = st.get_site_settings() self.site.set_site_info(infoSite[0], infoSite[1], infoSite[2]) infoGeo = st.get_geographic_settings() # infoGeo[3], infoGeo[4] self.geo.set_geography(infoGeo[0], infoGeo[1], infoGeo[4]) infoSun = st.get_moonsun_settings() self.sun.set_sun(str(infoSun[0]), infoSun[1], str(infoSun[2]), str(infoSun[3])) except Exception as e: print(e) def save_settings(self): try: st = ConfigProject() self.save_site(st) self.save_geo(st) self.save_sun(st) st.save_settings() except Exception as e: print(e) def save_site(self, set): info1 = self.site.get_site_info() set.set_site_settings(info1[0], info1[1], info1[2]) def save_geo(self, set): info2 = self.geo.get_geography() # info2[2], info2[3], info2[4] set.set_geographic_settings(info2[0], info2[1], '0', '0', '0') def save_sun(self, set): info3 = self.sun.get_sun() set.set_moonsun_settings(info3[0], info3[1], info3[2], info3[3]) def setting_up(self): '''self.setLayout(set_lvbox(set_hbox(self.site), set_hbox(self.geo), set_hbox(self.sun), set_hbox(self.button_ok, self.button_clear, self.button_cancel, stretch2=1)))''' grid = QGridLayout() grid.addWidget(self.setting_up_site()) grid.addWidget(self.setting_up_geo()) grid.addWidget(self.setting_up_sun()) grid.addWidget(self.setting_up_buttons()) self.setLayout(grid) return grid def setting_up_site(self): group_box = QGroupBox("&Site Settings:") group_box.setCheckable(True) group_box.setChecked(False) group_box.setLayout(self.site.setting_up()) return group_box def setting_up_geo(self): group_box = QGroupBox("&Geographic Settings:") group_box.setCheckable(True) group_box.setChecked(False) group_box.setLayout(self.geo.setting_up()) return group_box def setting_up_sun(self): group_box = QGroupBox("&Sun and Moon Options:") group_box.setCheckable(True) group_box.setChecked(False) group_box.setLayout(self.sun.setting_up()) return group_box def setting_up_buttons(self): group_box = QGroupBox() group_box.setLayout(set_hbox(self.button_ok, self.button_clear, self.button_cancel)) return group_box
class Camera(metaclass=Singleton): ''' classe de controle que faz comunicao com a camera fisica. ''' def __init__(self): self.lock = Locker() self.console = ConsoleThreadOutput() self.settings = SettingsCamera() self.settings.setup_settings() self.fan = Fan() # Campos da janela principal para as informações da câmera self.firmware_field = None self.model_field = None self.valor_pixels_x = None self.valor_pixels_y = None self.main = Status() self.now_plus = datetime.now() self.settedhour = datetime.now() """ executa o modo manual continuousShooterThread """ self.continuousShooterThread = ContinuousShooterThread( int(self.settings.get_camera_settings()[4])) """ executa o modo automatico ephemerisShooterThread """ self.ephemerisShooterThread = EphemerisShooter() self.sthread = SThread() self.commands = CameraQThread(self) self.shooting = False # Initiating the Slots self.init_slots() self.info_ini = [] self.pass_list = [1024, 1024] self.pass_list_str = ["1024", "1024"] info_ini = self.get_camera_settings_ini() self.aux_temperature = int(info_ini[0]) self.temp = 0 self.temp_contador = False self.temp_contador_manual = False self.is_connected = False def init_slots(self): """ Ephemeris Shooter Slots """ self.ephemerisShooterThread.started.connect(self.eshooter_started) self.ephemerisShooterThread.finished.connect(self.eshooter_finished) self.ephemerisShooterThread.signal_started_shooting.connect( self.shooter_mode) self.ephemerisShooterThread.signal_temp.connect(self.check_temp) self.ephemerisShooterThread.continuousShooterThread.signal_temp.connect( self.check_temp) self.ephemerisShooterThread.continuousShooterThread.started.connect( self.eshooter_observation_started) self.ephemerisShooterThread.continuousShooterThread.finished.connect( self.eshooter_observation_finished) """ Criando connect da temperatura """ # self.ephemerisShooterThread.continuousShooterThread.signalAfterShooting.connect() self.continuousShooterThread.signal_temp.connect( self.check_temp_manual) self.continuousShooterThread.finished.connect(self.standby_mode) # Camera Commands Slots self.commands.finished.connect(self.eita) self.commands.connectSignal.connect(self.connect_mainwindow_update) def get_firmware_and_model_and_pixels(self): info = self.get_info() return str(info[0]), str(info[2])[2:len(str(info[2])) - 1], str( info[-2]), str(info[-1]) def get_model_and_pixels_new(self): return self.model_field.text(), self.valor_pixels_x.text( ), self.valor_pixels_y.text() def set_firmware_and_model_fields(self, modelField, X_Pixels, Y_Pixels): # self.firmware_field = firmwareField self.model_field = modelField self.valor_pixels_x = X_Pixels self.valor_pixels_y = Y_Pixels def set_firmware_and_model_values(self): firmware, model, y_pixels, x_pixels = self.get_firmware_and_model_and_pixels( ) # self.firmware_field.setText("Firmware: " + firmware) self.model_field.setText("Camera: " + model) self.valor_pixels_x.setText(x_pixels + " X ") self.valor_pixels_y.setText(y_pixels + " Pixels") self.pass_list = [ int(self.valor_pixels_x.text().split(" ")[0]), int(self.valor_pixels_y.text().split(" ")[0]) ] self.pass_list_str = [ self.valor_pixels_x.text().split(" ")[0], self.valor_pixels_y.text().split(" ")[0] ] def clear_firmware_and_model_values(self): # self.firmware_field.setText("Firmware: ") self.model_field.setText("Camera: ") def get_info(self): ''' Function to get the CCD Info This function will return [CameraFirmware, CameraType, CameraName, Pixels] ''' ret = None self.lock.set_acquire() try: ret = tuple(ccdinfo()) except Exception as e: self.console.raise_text( "Failed to get camera information.\n{}".format(e)) finally: self.lock.set_release() return ret def connect(self): try: a = open_driver() open_deviceusb() c = establishinglink() if a is True and c is True: self.console.raise_text("Open Device = {}".format(a), 2) time.sleep(1) # self.console.save_log("Open Device = {}".format(a)) self.console.raise_text("Established Link = {}".format(c), 2) time.sleep(1) # self.console.save_log("Established Link = {}".format(c)) self.console.raise_text("Successfully connected!", 2) time.sleep(1) # self.console.save_log("Successfully connected!") self.set_firmware_and_model_values() self.is_connected = True ''' Fan Field sera atualizado automaticamente atualizado pela thread de refresh temp. ''' # self.fan.refresh_fan_status() return True else: self.is_connected = False self.console.raise_text("Connection error", 3) except Exception as e: self.is_connected = False self.console.raise_text( 'Failed to connect the camera!\n{}'.format(e), 3) return False def disconnect(self): try: self.standby_mode() cd = close_device() cdr = close_driver() if cd and cdr: self.console.raise_text("Close Device = {}".format(cd), 2) self.console.raise_text("Close Driver = {}".format(cdr), 2) self.console.raise_text("Successfully disconnected", 2) self.clear_firmware_and_model_values() self.is_connected = False else: self.console.raise_text( "Error disconnect! {} {}".format(cd, cdr), 3) except Exception as e: self.console.raise_text( "It failed to disconnect the camera!\n{}".format(e), 3) def set_temperature(self, value): if getlinkstatus() is True: self.lock.set_acquire() try: set_temperature(regulation=True, setpoint=value, autofreeze=False) except Exception as e: self.console.raise_text( "Error setting the temperature.\n{}".format(e), 3) finally: self.lock.set_release() self.console.raise_text( "Temperature set to {}°C".format(int(value)), 1) time.sleep(1) # self.check_fan() # self.console.save_log("Temperature set to {}°C".format(int(value))) else: self.console.raise_text("The camera is not connected!", 3) def get_temperature(self): temp = "NAN" try: if getlinkstatus() is True: if not self.lock.is_locked(): self.lock.set_acquire() temp = get_temperature()[3] self.temp = temp self.lock.set_release() # else: # if getlinkstatus() is True: # sleep(1) # self.lock.set_acquire() # temp = tuple(get_temperature())[3] # self.lock.set_release() # temp = "None", except Exception as e: self.console.raise_text( "Unable to retrieve the temperature.\n{}".format(e), 3) time.sleep(1) temp = "NAN" return temp def check_link(self): return getlinkstatus() def get_camera_settings_ini(self): settings = SettingsCamera() info_ini = settings.get_camera_settings() return info_ini # Camera Mode def standby_mode(self): self.set_temperature(15.00) self.fan.set_fan_off() self.check_fan() def check_fan(self): if SbigDriver.is_fanning(): self.console.raise_text("Fan: ON", 2) time.sleep(1) else: self.console.raise_text("Fan: OFF", 2) time.sleep(1) def shooter_mode(self): info_ini = self.get_camera_settings_ini() self.aux_temperature = int(info_ini[0]) self.set_temperature(int(self.aux_temperature)) self.fan.set_fan_on() self.check_fan() self.console.raise_text( "Waiting temperature to " + str(self.aux_temperature) + "°C", 2) time.sleep(1) # Shooters def start_one_photo(self): try: self.continuousShooterThread.one_photo = True self.continuousShooterThread.wait_temperature = True self.continuousShooterThread.start_continuous_shooter() self.continuousShooterThread.start() except Exception as e: print(e) def start_taking_photo(self): try: if getlinkstatus() is True: self.shooter_mode() self.continuousShooterThread.start_continuous_shooter() self.continuousShooterThread.start() else: self.console.raise_text("The camera is not connected", 3) except Exception as e: print(e) def stop_taking_photo(self): if getlinkstatus() is True: if not self.continuousShooterThread.wait_temperature: self.continuousShooterThread.stop_continuous_shooter() self.continuousShooterThread.stop_continuous_shooter() # self.standby_mode() else: self.console.raise_text("The camera is not connected!", 3) def log_ephem_infos(self): info_start_end = result() start_time = str(info_start_end[0]) start_field = start_time[:-10] + " UTC" end_time = str(info_start_end[1]) end_field = end_time[:-10] + " UTC" ''' time_obs_time = str(info_start_end[2]).split(":") time_obs_time = [z.split(".")[0] for z in time_obs_time] time_obs_field = time_obs_time[0] + ":" + time_obs_time[1] + " Hours" ''' # self.console.raise_text("Start Time: " + start_field + "; End Time: " + end_field, 2) self.console.save_log("Start Time: " + start_field + "; End Time: " + end_field) time.sleep(1) def start_ephemeris_shooter(self): if getlinkstatus() is True: self.ephemerisShooterThread.start() else: self.console.raise_text("The camera is not connected!", 3) def stop_ephemeris_shooter(self): if getlinkstatus() is True: self.ephemerisShooterThread.stop_shooter() # self.standby_mode() else: self.console.raise_text("The camera is not connected!", 3) # All PyQt Slots def eshooter_started(self): self.console.raise_text("Shooter Ephemeris Started!", 1) time.sleep(1) # self.console.save_log("Shooter Ephemeris Started!") self.log_ephem_infos() self.standby_mode() def eshooter_finished(self): self.console.raise_text('Shooter Finished\n', 2) time.sleep(1) self.log_ephem_infos() self.standby_mode() def eshooter_observation_started(self): self.shooting = True self.console.raise_text("Observation Started\n", 2) time.sleep(1) self.log_ephem_infos() def eshooter_observation_finished(self): self.console.raise_text("Observation Finalized", 2) self.standby_mode() self.continuousShooterThread.wait_temperature = False self.continuousShooterThread.one_photo = False self.ephemerisShooterThread.wait_temperature = False self.ephemerisShooterThread.continuousShooterThread.wait_temperature = False self.temp_contador_manual = 0 self.shooting = False self.log_ephem_infos() # Commands Slots def check_temp_manual(self): ''' funcao que espera temperatura setada ou tempo pre-determinado ''' try: now = datetime.now() if not self.temp_contador_manual: self.now_plus = now + timedelta( seconds=int(self.settings.get_camera_settings()[5])) self.temp_contador_manual = True elif self.temp <= int( self.aux_temperature) or now >= self.now_plus: self.continuousShooterThread.wait_temperature = True self.temp_contador_manual = False else: self.temp_contador_manual = True except Exception as e: print(e) def check_temp(self): ''' funcao que espera temperatura setada ou tempo pre-determinado ''' try: now = datetime.now() if not self.temp_contador: self.now_plus = now + timedelta( seconds=int(self.settings.get_camera_settings()[5])) self.temp_contador = True if self.temp <= int(self.aux_temperature) or now >= self.now_plus: self.ephemerisShooterThread.wait_temperature = True self.ephemerisShooterThread.continuousShooterThread.wait_temperature = True self.temp_contador = False except Exception as e: print(e) def connect_mainwindow_update(self): self.set_firmware_and_model_values() self.fan.refresh_fan_status() def eita(self): self.console.raise_text(self.commands.text, 1)
class ContinuousShooterThread(QtCore.QThread): # classe para modo manual signalAfterShooting = QtCore.pyqtSignal(name="signalAfterShooting") signal_temp = QtCore.pyqtSignal(name="signalTemp") def __init__(self, time_sleep): super(ContinuousShooterThread, self).__init__() self.continuous = True # SThread manda para o Sbigdriver as informações para se tirar a foto em si. self.ss = SThread() self.photo_type = self.ss.recebe_argumento self.ss.started.connect(self.thread_iniciada) self.console = ConsoleThreadOutput() self.count = 0 self.wait_temperature = False self.not_two_dark = True self.one_photo = False self.one_photo_shutter_state = None self.select_filter_manual = None self.select_filter_shutter = None def recebe_args(self, select_filter_manual, select_filter_shutter): self.select_filter_manual = select_filter_manual self.select_filter_shutter = select_filter_shutter print("\n\nself.select_filter_shutter") print(self.select_filter_shutter) print("\nself.select_filter_manual") print(self.select_filter_manual) print("\n\n") def run(self): try: self.count = 1 while self.continuous: try: self.signal_temp.emit() if self.wait_temperature: if self.count <= 1 and not self.one_photo: self.console.raise_text("Taking dark photo", 1) self.start_dark_sthread() print("\n\nself.select_filter_shutter") print(self.select_filter_shutter) print("\n\n") if self.select_filter_shutter == "Closed" and self.one_photo: self.ss.recebe_argumento(1) else: self.ss.recebe_argumento(0) if self.one_photo: self.ss.args_one_photo(self.select_filter_manual, self.select_filter_shutter) self.ss.start() if self.one_photo: break while self.ss.isRunning(): time.sleep(1) self.signalAfterShooting.emit() except Exception as e: print(e) time.sleep(1) except Exception as e: print("Exception Run ContinuousShooterThread ->" + str(e)) finally: if not self.one_photo: self.console.raise_text("Taking dark photo", 1) self.start_dark_sthread() self.one_photo = False def start_continuous_shooter(self): self.continuous = True def stop_continuous_shooter(self): self.wait_temperature = False self.continuous = False self.not_two_dark = False # self.console.raise_text("Taking dark photo", 1) self.count = 1 def stop_one_photo(self): self.one_photo = False self.wait_temperature = False self.continuous = False self.count = 1 def thread_iniciada(self): if self.one_photo: self.console.raise_text("Taking photo", 1) self.stop_one_photo() else: self.console.raise_text("Taking photo N: {}".format(self.count), 1) self.count += 1 def start_dark_sthread(self): if not self.one_photo: try: self.ss.recebe_argumento(1) self.ss.start() while self.ss.isRunning(): time.sleep(1) except Exception as e: print("Error start_dark_sthread! {}".format(e)) self.console.raise_text("Error start_dark_sthread! {}".format(e), 3) finally: self.count = 1
class EphemerisShooter(QtCore.QThread): signal_started_shooting = QtCore.pyqtSignal(name="signalStartedShooting") signal_temp = QtCore.pyqtSignal(name="signalTemp") def __init__(self): super(EphemerisShooter, self).__init__() self.camconfig = SettingsCamera() self.camconfig.setup_settings() infocam = self.camconfig.get_camera_settings() self.ObserverFactory = EphemObserverFactory() self.continuousShooterThread = ContinuousShooterThread(int(infocam[4])) self.console = ConsoleThreadOutput() self.config = ConfigProject() info = self.config.get_geographic_settings() infosun = self.config.get_moonsun_settings() self.latitude = info[0] # '-45.51' self.longitude = info[1] # '-23.12' self.elevation = info[2] # 350 self.max_solar_elevation = infosun[0] # -12 self.ignore_lunar_position = infosun[1] self.max_lunar_elevation = infosun[2] # 8 self.max_lunar_phase = infosun[3] # 1 self.t = False print(int(infocam[4])) try: self.s = int(infocam[4]) self.continuousShooterThread.set_sleep_time(self.s) except Exception as e: self.s = 5 self.shootOn = False self.controller = True self.count = 1 def refresh_data(self): try: info = self.config.get_geographic_settings() self.latitude = info[0] # '-45.51' self.longitude = info[1] # '-23.12' self.elevation = info[2] # 350 infosun = self.config.get_moonsun_settings() self.max_solar_elevation = float(infosun[0]) # -12 self.ignore_lunar_position = infosun[1] self.max_lunar_elevation = float(infosun[2]) # 8 self.max_lunar_phase = float(infosun[3]) # 1 except Exception as e: self.console.raise_text("Exception thrown to acquire information\n" "Please set an observatory information on settings\n" + str(e), level=3) self.latitude = 0 self.longitude = 0 self.elevation = 0 self.max_solar_elevation = 0 self.max_lunar_elevation = 0 self.max_lunar_phase = 0 infocam = self.camconfig.get_camera_settings() try: self.s = int(infocam[4]) except Exception as e: self.s = 0 def calculate_moon(self, obs): aux = obs aux.compute_pressure() aux.horizon = '8' moon = ephem.Moon(aux) return aux.previous_setting(moon), aux.next_rising(moon) def calculate_sun(self, obs): aux = obs aux.compute_pressure() aux.horizon = '-12' sun = ephem.Sun(aux) return aux.previous_setting(sun), aux.next_rising(sun) def set_solar_and_lunar_parameters(self, maxSolarElevation, maxLunarElevation, maxLunarPhase): self.max_solar_elevation = maxSolarElevation self.max_lunar_elevation = maxLunarElevation self.max_lunar_phase = maxLunarPhase def run(self): self.refresh_data() obs = self.ObserverFactory.create_observer(longitude=self.longitude, latitude=self.latitude, elevation=self.elevation) self.controller = True self.shootOn = False c = 0 try: while self.controller: obs.date = ephem.date(datetime.datetime.utcnow()) sun = ephem.Sun(obs) moon = ephem.Moon(obs) frac = moon.moon_phase a = ephem.degrees(sun.alt) b = ephem.degrees(str(moon.alt)) # Variavel de controle do shooter t = 1 if float(math.degrees(a)) < self.max_solar_elevation or t == 1: if (self.ignore_lunar_position == False and float(math.degrees(b)) < self.max_lunar_elevation and frac < self.max_lunar_phase) or self.ignore_lunar_position: if not self.shootOn: if not c: self.signal_started_shooting.emit() c = 1 self.signal_temp.emit() time.sleep(5) if self.t: # Iniciar as Observações self.start_taking_photo() self.shootOn = True else: if self.shootOn: # Finalizar as Observações self.stop_taking_photo() c = 0 self.shootOn = False time.sleep(5) except Exception as e: self.console.raise_text("Exception no Ephemeris Shooter -> " + str(e)) def stop_shooter(self): self.controller = False self.continuousShooterThread.stop_continuous_shooter() def start_taking_photo(self): self.continuousShooterThread.set_sleep_time(self.s) self.continuousShooterThread.start_continuous_shooter() self.continuousShooterThread.start() def stop_taking_photo(self): self.continuousShooterThread.stop_continuous_shooter()
class Camera(metaclass=Singleton): ''' classe de controle da camera ''' def __init__(self): self.lock = Locker() self.console = ConsoleThreadOutput() self.settings = SettingsCamera() self.settings.setup_settings() self.fan = Fan() # Campos da janela principal para as informações da câmera self.firmware_field = None self.model_field = None self.main = Status() self.now_plus_10 = datetime.now() self.settedhour = datetime.now() self.continuousShooterThread = ContinuousShooterThread( int(self.settings.get_camera_settings()[4])) self.ephemerisShooterThread = EphemerisShooter() self.sthread = SThread() self.commands = CameraQThread(self) self.shooting = False # Initiating the Slots self.init_slots() self.info_ini = [] info_ini = self.get_camera_settings_ini() self.aux_temperature = int(info_ini[0]) self.temp = 0 self.temp_contador = 0 self.temp_contador_manual = 0 def init_slots(self): # Ephemeris Shooter Slots self.ephemerisShooterThread.started.connect(self.eshooter_started) self.ephemerisShooterThread.finished.connect(self.eshooter_finished) self.ephemerisShooterThread.signal_started_shooting.connect( self.shooter_mode) self.ephemerisShooterThread.signal_temp.connect(self.check_temp) self.ephemerisShooterThread.continuousShooterThread.signal_temp.connect( self.check_temp) self.ephemerisShooterThread.continuousShooterThread.started.connect( self.eshooter_observation_started) self.ephemerisShooterThread.continuousShooterThread.finished.connect( self.eshooter_observation_finished) # Criando connect da temperatura # self.ephemerisShooterThread.continuousShooterThread.signalAfterShooting.connect() self.continuousShooterThread.signal_temp.connect( self.check_temp_manual) self.continuousShooterThread.finished.connect(self.standby_mode) # Camera Commands Slots self.commands.finished.connect(self.eita) self.commands.connectSignal.connect(self.connect_mainwindow_update) def get_firmware_and_model(self): info = self.get_info() return str(info[0]), str(info[2])[2:len(str(info[2])) - 1] def set_firmware_and_model_fields(self, firmwareField, modelField): self.firmware_field = firmwareField self.model_field = modelField def set_firmware_and_model_values(self): firmware, model = self.get_firmware_and_model() self.firmware_field.setText("Firmware: " + firmware) self.model_field.setText("Camera: " + model) def clear_firmware_and_model_values(self): self.firmware_field.setText("Firmware: ") self.model_field.setText("Camera: ") def get_info(self): ''' Function to get the CCD Info This function will return [CameraFirmware, CameraType, CameraName] ''' ret = None self.lock.set_acquire() try: ret = tuple(ccdinfo()) except Exception as e: self.console.raise_text( "Failed to get camera information.\n{}".format(e)) finally: self.lock.set_release() return ret def connect(self): try: a = open_driver() open_deviceusb() c = establishinglink() if a is True and c is True: self.console.raise_text("Open Device = {}".format(a), 2) self.console.raise_text("Established Link = {}".format(c), 2) self.console.raise_text("Successfully connected!", 2) self.set_firmware_and_model_values() ''' Fan Field sera atualizado automaticamente atualizado pela thread de refresh temp. ''' # self.fan.refresh_fan_status() return True else: self.console.raise_text("Connection error", 3) except Exception as e: self.console.raise_text( 'Failed to connect the camera!\n{}'.format(e), 3) return False def disconnect(self): try: self.standby_mode() cd = close_device() cdr = close_driver() if cd and cdr: self.console.raise_text("Close Device = {}".format(cd), 2) self.console.raise_text("Close Driver = {}".format(cdr), 2) self.console.raise_text("Successfully disconnected", 2) self.clear_firmware_and_model_values() else: self.console.raise_text( "Error disconnect! {} {}".format(cd, cdr), 3) except Exception as e: self.console.raise_text( "It failed to disconnect the camera!\n{}".format(e), 3) def set_temperature(self, value): if getlinkstatus() is True: self.lock.set_acquire() try: set_temperature(regulation=True, setpoint=value, autofreeze=False) except Exception as e: self.console.raise_text( "Error setting the temperature.\n{}".format(e), 3) finally: self.lock.set_release() self.console.raise_text( "Temperature set to {}°C".format(int(value)), 1) else: self.console.raise_text("The camera is not connected!", 3) def get_temperature(self): temp = "None" try: if getlinkstatus() is True: if not self.lock.is_locked(): self.lock.set_acquire() temp = tuple(get_temperature())[3] self.temp = temp self.lock.set_release() else: temp = "None" else: # if getlinkstatus() is True: # sleep(1) # self.lock.set_acquire() # temp = tuple(get_temperature())[3] # self.lock.set_release() temp = "None" except Exception as e: self.console.raise_text( "Unable to retrieve the temperature.\n{}".format(e), 3) return temp def check_link(self): return getlinkstatus() def get_camera_settings_ini(self): settings = SettingsCamera() info_ini = settings.get_camera_settings() return info_ini # Camera Mode def standby_mode(self): self.set_temperature(15.00) self.fan.set_fan_off() def shooter_mode(self): self.set_temperature(int(self.aux_temperature)) self.fan.set_fan_on() self.console.raise_text( "Waiting temperature to " + str(self.aux_temperature) + "°C", 2) # Shooters def start_taking_photo(self): try: if getlinkstatus() is True: self.shooter_mode() self.continuousShooterThread.start_continuous_shooter() self.continuousShooterThread.start() else: self.console.raise_text("The camera is not connected", 3) except Exception as e: print(e) def stop_taking_photo(self): if getlinkstatus() is True: self.continuousShooterThread.stop_continuous_shooter() else: self.console.raise_text("The camera is not connected!", 3) def start_ephemeris_shooter(self): if getlinkstatus() is True: self.ephemerisShooterThread.start() else: self.console.raise_text("The camera is not connected!", 3) def stop_ephemeris_shooter(self): if getlinkstatus() is True: self.ephemerisShooterThread.stop_shooter() else: self.console.raise_text("The camera is not connected!", 3) # All PyQt Slots def eshooter_started(self): self.console.raise_text("Shooter Ephemeris Started!", 1) self.standby_mode() def eshooter_finished(self): self.console.raise_text('Shooter finalized\n', 1) def eshooter_observation_started(self): self.shooting = True self.console.raise_text("Observation Started", 1) def eshooter_observation_finished(self): self.console.raise_text("Observation Finalized", 1) self.standby_mode() self.continuousShooterThread.wait_temperature = False self.ephemerisShooterThread.wait_temperature = False self.ephemerisShooterThread.continuousShooterThread.wait_temperature = False self.temp_contador_manual = 0 self.shooting = False # Commands Slots def check_temp_manual(self): ''' funcao que espera temperatura setada ou tempo pre-determinada ''' try: now = datetime.now() if self.temp_contador_manual == 0: self.now_plus_10 = datetime.now() + timedelta(minutes=10) self.temp_contador_manual += 2 elif self.temp <= int( self.aux_temperature) or now >= self.now_plus_10: self.continuousShooterThread.wait_temperature = True self.temp_contador_manual = 0 else: self.temp_contador_manual += 2 except Exception as e: print(e) def check_temp(self): ''' funcao que espera temperatura setada ou tempo pre-determinada ''' try: now = datetime.now() if self.temp_contador == 0: self.now_plus_10 = datetime.now() + timedelta(minutes=10) self.temp_contador += 1 if self.temp <= int( self.aux_temperature) or now >= self.now_plus_10: self.ephemerisShooterThread.wait_temperature = True self.ephemerisShooterThread.continuousShooterThread.wait_temperature = True self.temp_contador = 0 except Exception as e: print(e) def connect_mainwindow_update(self): self.set_firmware_and_model_values() self.fan.refresh_fan_status() def eita(self): self.console.raise_text(self.commands.text, 1)
class Camera(metaclass=Singleton): def __init__(self): self.lock = Locker() self.console = ConsoleThreadOutput() self.settings = SettingsCamera() self.settings.setup_settings() self.fan = Fan() # Campos da janela principal para as informações da câmera self.firmware_field = None self.model_field = None self.main = Status() self.settedhour = datetime.now() self.continuousShooterThread = ContinuousShooterThread(int(self.settings.get_camera_settings()[4])) self.ephemerisShooterThread = EphemerisShooter() self.commands = CameraQThread(self) self.shooting = False # Initiating the Slots self.init_slots() self.temp = 0 self.temp_contador = 0 def init_slots(self): # Ephemeris Shooter Slots self.ephemerisShooterThread.started.connect(self.eshooter_started) self.ephemerisShooterThread.finished.connect(self.eshooter_finished) self.ephemerisShooterThread.signal_started_shooting.connect(self.shooter_mode) self.ephemerisShooterThread.signal_temp.connect(self.check_temp) self.ephemerisShooterThread.continuousShooterThread.started.connect(self.eshooter_observation_started) self.ephemerisShooterThread.continuousShooterThread.finished.connect(self.eshooter_observation_finished) # Criando connect da temperatura # self.ephemerisShooterThread.continuousShooterThread.signalAfterShooting.connect() self.continuousShooterThread.finished.connect(self.standby_mode) # Camera Commands Slots self.commands.finished.connect(self.eita) self.commands.connectSignal.connect(self.connect_mainwindow_update) def get_firmware_and_model(self): info = self.get_info() return str(info[0]), str(info[2])[2:len(str(info[2]))-1] def set_firmware_and_model_fields(self, firmwareField, modelField): self.firmware_field = firmwareField self.model_field = modelField def set_firmware_and_model_values(self): firmware, model = self.get_firmware_and_model() self.firmware_field.setText("Firmware: " + firmware) self.model_field.setText("Camera: " + model) def clear_firmware_and_model_values(self): self.firmware_field.setText("Firmware: ") self.model_field.setText("Camera: ") def get_info(self): """ Function to get the CCD Info This function will return [CameraFirmware, CameraType, CameraName] """ ret = None self.lock.set_acquire() try: ret = tuple(ccdinfo()) except Exception as e: self.console.raise_text("Failed to get camera information.\n{}".format(e)) finally: self.lock.set_release() return ret def connect(self): try: a = open_driver() open_deviceusb() c = establishinglink() if a is True and c is True: self.console.raise_text("Successfully connected! {} {}".format(a, c), 2) self.set_firmware_and_model_values() ''' Fan Field sera atualizado automaticamente atualizado pela thread de refresh temp. ''' # self.fan.refresh_fan_status() return True else: self.console.raise_text("Connection error", 3) except Exception as e: self.console.raise_text('Failed to connect the camera!\n{}'.format(e), 3) return False def disconnect(self): try: self.standby_mode() cd = close_device() cdr = close_driver() if cd and cdr: self.console.raise_text("Successfully disconnected!{} {}".format(cd, cdr), 2) self.clear_firmware_and_model_values() else: self.console.raise_text("Error disconnect! {} {}".format(cd, cdr), 3) except Exception as e: self.console.raise_text("It failed to disconnect the camera!\n{}".format(e), 3) def set_temperature(self, value): if getlinkstatus() is True: self.lock.set_acquire() try: set_temperature(regulation=True, setpoint=value, autofreeze=False) except Exception as e: self.console.raise_text("Error setting the temperature.\n{}".format(e), 3) finally: self.lock.set_release() self.console.raise_text("Temperature set to {}".format(int(value)), 1) else: self.console.raise_text("The camera is not connected!", 3) def get_temperature(self): temp = "None" try: if getlinkstatus() is True: if not self.lock.is_locked(): self.lock.set_acquire() temp = tuple(get_temperature())[3] self.temp = temp self.lock.set_release() else: temp = "None" else: # if getlinkstatus() is True: # sleep(1) # self.lock.set_acquire() # temp = tuple(get_temperature())[3] # self.lock.set_release() # else: temp = "None" except Exception as e: self.console.raise_text("Unable to retrieve the temperature.\n{}".format(e), 3) return temp def check_link(self): return getlinkstatus() # Camera Mode def standby_mode(self): self.set_temperature(15.00) self.fan.set_fan_off() def shooter_mode(self): self.set_temperature(-16.00) self.fan.set_fan_on() while self.get_temperature() < -15: sleep(1) # Shooters def start_taking_photo(self): try: if getlinkstatus() is True: self.continuousShooterThread.start_continuous_shooter() self.continuousShooterThread.start() else: self.console.raise_text("The camera is not connected", 3) except Exception as e: print(e) def stop_taking_photo(self): if getlinkstatus() is True: self.continuousShooterThread.stop_continuous_shooter() else: self.console.raise_text("The camera is not connected!", 3) def start_ephemeris_shooter(self): if getlinkstatus() is True: self.ephemerisShooterThread.start() else: self.console.raise_text("The camera is not connected!", 3) def stop_ephemeris_shooter(self): if getlinkstatus() is True: self.ephemerisShooterThread.stop_shooter() else: self.console.raise_text("The camera is not connected!", 3) # All PyQt Slots def eshooter_started(self): self.console.raise_text("Shooter Ephemeris Started!", 1) self.standby_mode() def eshooter_finished(self): self.console.raise_text('Shooter finalized', 1) def eshooter_observation_started(self): self.shooting = True self.console.raise_text("Observation Started", 1) def eshooter_observation_finished(self): self.console.raise_text("Observation Finalized", 1) self.standby_mode() self.shooting = False # Commands Slots def check_temp(self): if self.temp <= -15 or self.temp_contador == 60: self.ephemerisShooterThread.t = True else: self.console.raise_text("Temp_contador = " + str(self.temp_contador), 1) self.console.raise_text("CCD cooling to -15", 1) self.temp_contador += 1 def connect_mainwindow_update(self): self.set_firmware_and_model_values() self.fan.refresh_fan_status() def eita(self): self.console.raise_text(self.commands.text, 1)
class SettingsWindow(QtWidgets.QWidget): def __init__(self, parent=None): super(SettingsWindow, self).__init__(parent) self.cam = SettingsCamera() self.camera = Camera() self.console = ConsoleThreadOutput() #self.a_temp_regulation = TempRegulation(self) self.create_cam_widgets() self.p = parent self.fan = Fan(self.fanButton) #self.button_clear = QtWidgets.QPushButton('Clear', self) self.setField_temperature = QtWidgets.QLineEdit(self) self.setting_values() self.setLayout(set_lvbox(set_hbox(self.setField_temperature_label, self.setField_temperature), set_hbox(self.pre, self.prel), set_hbox(self.exp, self.expl), set_hbox(self.binning, self.combo), set_hbox(self.tempo_fotos_label, self.tempo_fotos), set_hbox(self.tempButton, self.fanButton, stretch2=1), set_hbox(self.buttonok, self.button_clear, self.buttoncancel, stretch2=1))) def get_values(self): return self.cam.get_camera_settings() def setting_values(self): info = self.get_values() self.set_values(info[0], info[1], info[2], info[3], info[4]) def set_values(self, temperature_camera, prefixo, exposicao, binning, tempo_entre_fotos): self.setField_temperature.setText(temperature_camera) self.prel.setText(prefixo) self.expl.setText(exposicao) try: b = int(binning) except: b = 0 self.tempo_fotos.setText(tempo_entre_fotos) self.combo.setCurrentIndex(b) def create_cam_widgets(self): self.setField_temperature_label = QtWidgets.QLabel("Temperature:", self) self.pre = QtWidgets.QLabel("Filter:", self) self.prel = QtWidgets.QLineEdit(self) self.exp = QtWidgets.QLabel("Exposure time:", self) self.expl = QtWidgets.QLineEdit(self) self.binning = QtWidgets.QLabel("Binning:", self) self.combo = QtWidgets.QComboBox(self) self.fill_combo() self.button_clear = QtWidgets.QPushButton('Clear', self) self.button_clear.clicked.connect(self.clear_all) self.tempButton = QtWidgets.QPushButton("Set Temp", self) self.tempButton.clicked.connect(self.btn_temperature) self.fanButton = QtWidgets.QPushButton("Fan") self.fanButton.clicked.connect(self.button_fan_func) self.buttonok = QtWidgets.QPushButton("Save", self) self.buttonok.clicked.connect(self.button_ok_func) self.buttoncancel = QtWidgets.QPushButton("Cancel", self) self.buttoncancel.clicked.connect(self.func_cancel) self.tempo_fotos_label = QtWidgets.QLabel("Time between photos:", self) self.tempo_fotos = QtWidgets.QLineEdit(self) def button_ok_func(self): try: # Setting the Temperature '''value = self.setField_temperature.text() if value is '': value = 20 self.camera.set_temperature(float(value))''' # Saving the Settings self.cam.set_camera_settings(self.setField_temperature.text(), self.prel.text(), self.expl.text(), self.combo.currentIndex(), self.tempo_fotos.text()) self.cam.save_settings() self.console.raise_text("Camera settings successfully saved!", 1) except Exception as e: self.console.raise_text("Camera settings were not saved.", 3) finally: self.p.close() def clear_all(self): self.setField_temperature.clear() self.prel.clear() self.expl.clear() self.tempo_fotos.clear() def func_cancel(self): self.p.close() def button_fan_func(self): if getlinkstatus() is True: try: self.fan.set_fan() self.console.raise_text('State changed Fan!', 2) except Exception: self.console.raise_text("The camera is not connected!", 3) self.console.raise_text('State Fan unchanged', 3) else: self.console.raise_text("The camera is not connected!", 3) self.console.raise_text('State Fan unchanged', 3) def fill_combo(self): self.combo.addItem("1x1", 0) self.combo.addItem("2x2", 1) self.combo.addItem("3x3", 2) def btn_temperature(self): try: value = self.setField_temperature.text() if value is '': pass else: self.camera.set_temperature(float(value)) except Exception as e: print("Exception -> {}".format(e))