def flock_demo(args=None):
# TODO: Make this an actual flock
print(
'Please make sure that the simulator is running.\n'
'You can start it by running the following command in another terminal:\n\n'
'lantz sims fungen tcp')
# We import a helper function to start the app
from lantz.qt import start_gui_app, wrap_driver_cls
# The block consists of two parts the backend and the frontend
from lantz.qt.blocks import FeatScan, FeatScanUi
# An this you know already
from lantz.drivers.examples import LantzSignalGenerator
QLantzSignalGenerator = wrap_driver_cls(LantzSignalGenerator)
with QLantzSignalGenerator('TCPIP::localhost::5678::SOCKET') as fungen:
# Here we instantiate the backend setting 'frequency' as the Feat to scan
# and specifying in which instrument
app = FeatScan('frequency', instrument=fungen)
# Now we use the helper to start the app.
# It takes a Backend instance and a FrontEnd class
start_gui_app(app, FeatScanUi)
# or comment this line to stop logging
log_to_screen(DEBUG)
# Instead of using the TemperatureSensor driver, we automagically create
# a Qt aware version of it. This allows
QTemperatureSensor = wrap_driver_cls(TemperatureSensor)
# We initialize the board via the packfile to autodetect it.
# You can alternative use the COMPORT using the `via_serial`
# However, notice that using the packfile is superior as it allows you:
# - to check if the software on the arduino is up to date with the version on your computer.
# and update it if necessary.
# - works even if the comport has changed
# - you can specify the model and/or serialno of the board to use a particular one
# if you have many connected.
# The `with` syntax as equivalent to:
# - instantiate the driver
# - initialize the driver
# - finalize the driver (even if there was a bug and the software crashes!)
with QTemperatureSensor.via_packfile('TemperatureSensor.pack.yaml',
check_update=True) as board:
# We then create the backend and provide the driver we have just created
# This will be bound to the corresponding instrument slot
app = TemperatureMonitor(interval=5 * ureg.second, board=board)
# Then we use the start_gui_app. Notice that we provide the class for the Ui, not an instance
start_gui_app(app, TemperatureMonitorUi)
from uc480.core.app import SpectraAnalyzer, SpectraAnalyzerUi, SpectraSave, SpectraSaveUi, SpectraViewerUi, SpectraMainUi from uc480.utilities import enums from lantz.core import ureg from lantz.qt.app import Backend, Frontend, InstrumentSlot, QtCore from lantz.qt.app import BackendSlot from lantz.core.log import log_to_screen, log_to_socket, DEBUG, ERROR from lantz.qt import start_gui_app, wrap_driver_cls # log_to_socket(DEBUG) log_to_screen(DEBUG) spectra_be = SpectraAnalyzer(camera_control_backend=None) # Then we use the start_gui_app. Notice that we provide the class for the Ui, not an instance start_gui_app(spectra_be, SpectraAnalyzerUi)
def turn_on_LED_method(self):
self.board.led = True
def turn_off_LED_method(self):
self.board.led = False
class LEDUserInterfase(Frontend):
gui = 'LED.ui'
def connect_backend(self):
super().connect_backend()
self.widget.turn_on_led_button.clicked.connect(
self.backend.turn_on_LED_method)
self.widget.turn_off_led_button.clicked.connect(
self.backend.turn_off_LED_method)
if __name__ == '__main__':
from lantz.core.log import log_to_screen, log_to_socket, DEBUG
from lantz.qt import start_gui_app, wrap_driver_cls
# ~ log_to_socket(DEBUG) # Uncommment this line to log to socket
log_to_screen(DEBUG) # or comment this line to stop logging
QLED = wrap_driver_cls(LEDDriver)
with QLED.via_packfile('LEDDriver.pack.yaml', check_update=True) as board:
app = LEDBackend(board=board)
start_gui_app(app, LEDUserInterfase)
# or comment this line to stop logging
log_to_screen(DEBUG)
# Instead of using the TemperatureSensor driver, we automagically create
# a Qt aware version of it. This allows
QTemperatureSensor = wrap_driver_cls(TemperatureSensor)
# We initialize the board via the packfile to autodetect it.
# You can alternative use the COMPORT using the `via_serial`
# However, notice that using the packfile is superior as it allows you:
# - to check if the software on the arduino is up to date with the version on your computer.
# and update it if necessary.
# - works even if the comport has changed
# - you can specify the model and/or serialno of the board to use a particular one
# if you have many connected.
# The `with` syntax as equivalent to:
# - instantiate the driver
# - initialize the driver
# - finalize the driver (even if there was a bug and the software crashes!)
with QTemperatureSensor.via_packfile('TemperatureSensor.pack.yaml',
check_update=True) as board:
# We then create the backend and provide the driver we have just created
# This will be bound to the corresponding instrument slot
app = TemperatureMonitor(interval=5 * ureg.second, board=board)
# Then we use the start_gui_app. Notice that we provide the class for the Ui, not an instance
start_gui_app(app, TemperaturePlotterUi)
from uc480.core.app import CameraSave as Backend from uc480.core.app import CameraSaveUi as Frontend from lantz.core.log import log_to_screen, DEBUG from lantz.qt import start_gui_app log_to_screen(DEBUG) backend = Backend(None) start_gui_app(backend, Frontend)
from uc480.core import Camera
from uc480.core import CameraControl, CameraSave, SpectraAnalyzer, SpectraSave, FFTAnalyzer, Main, MainUi
#from lantz.qt.app import build_qapp
if __name__ == '__main__':
from lantz.core.log import log_to_screen, log_to_socket, DEBUG, ERROR, INFO
from lantz.qt import start_gui_app, wrap_driver_cls
# log_to_socket(DEBUG)
log_to_screen(ERROR)
QCamera = wrap_driver_cls(Camera)
with QCamera() as camera:
control_be = CameraControl(camera=camera)
camera_save_be = CameraSave(camera_control_be=control_be)
spectra_be = SpectraAnalyzer(camera_control_backend=control_be)
save_be = SpectraSave(spectra_analyzer_be=spectra_be)
fft_be = FFTAnalyzer(spectra_analyzer_backend=spectra_be)
app = Main(control_be=control_be, camera_save_be=camera_save_be, spectra_be=spectra_be, save_be=save_be, fft_be=fft_be)
start_gui_app(app, MainUi)
from uc480.core import Camera
from uc480.core import CameraControl, CameraSave, CameraSaveUi, CameraMain, CameraSaveMainUi
from uc480.utilities import enums
import numpy as np
#from lantz.qt.app import build_qapp
if __name__ == '__main__':
from lantz.core.log import log_to_screen, log_to_socket, DEBUG, ERROR
from lantz.qt import start_gui_app, wrap_driver_cls
# log_to_socket(DEBUG)
log_to_screen(ERROR)
QCamera = wrap_driver_cls(Camera)
with QCamera() as camera:
control_be = CameraControl(camera=camera)
camera_save_be = CameraSave(camera_control_be=control_be)
app = CameraMain(control_be=control_be, camera_save_be=camera_save_be)
start_gui_app(camera_save_be, CameraSaveUi)
# or comment this line to stop logging
log_to_screen(DEBUG)
# Instead of using the TemperatureSensor driver, we automagically create
# a Qt aware version of it. This allows
QTemperatureSensor = wrap_driver_cls(TemperatureSensor)
# We initialize the board via the packfile to autodetect it.
# You can alternative use the COMPORT using the `via_serial`
# However, notice that using the packfile is superior as it allows you:
# - to check if the software on the arduino is up to date with the version on your computer.
# and update it if necessary.
# - works even if the comport has changed
# - you can specify the model and/or serialno of the board to use a particular one
# if you have many connected.
# The `with` syntax as equivalent to:
# - instantiate the driver
# - initialize the driver
# - finalize the driver (even if there was a bug and the software crashes!)
with QTemperatureSensor.via_packfile('TemperatureSensor.pack.yaml',
check_update=True) as board:
# We then create the backend and provide the driver we have just created
# This will be bound to the corresponding instrument slot
app = Temperature(board=board)
# Then we use the start_gui_app. Notice that we provide the class for the Ui, not an instance
start_gui_app(app, TemperatureUi)
def setupUi(self):
super().setupUi()
# Leftbar
self.l_leftbar = layout = get_layout0(vertical=True)
layout.addWidget(self.spectra_analyzer_ui)
layout.addWidget(self.spectra_save_ui)
layout.addStretch()
self.leftbar.setLayout(layout)
# Central, page 1
self.l_spectrum_page = layout = get_layout0(vertical=False)
layout.addWidget(self.spectra_viewer_ui)
self.spectrum_page.setLayout(layout)
log_to_screen(DEBUG)
spectra_analyzer_be = SpectraAnalyzer(None)
spectra_save_be = SpectraSave(None)
main_be = Main(spectra_analyzer_be=spectra_analyzer_be, spectra_save_be=spectra_save_be)
start_gui_app(main_be, MainUi)
from uc480.core import Camera, CameraControl, CameraControlUi
from uc480.utilities import enums
from lantz.core import ureg
from lantz.qt.app import Backend, Frontend, InstrumentSlot, QtCore
from lantz.qt.app import BackendSlot
from lantz.core.log import log_to_screen, log_to_socket, DEBUG, ERROR
from lantz.qt import start_gui_app, wrap_driver_cls
from pyueye import ueye
# log_to_socket(DEBUG)
log_to_screen(DEBUG)
QCamera = wrap_driver_cls(Camera)
with QCamera() as camera:
control_be = CameraControl(camera=camera)
start_gui_app(control_be, CameraControlUi)