예제 #1
0
def test_denormalize_brightness() -> None:
    with FakeBacklightSysfs() as backlight_sysfs:
        backlight = Backlight(backlight_sysfs_path=backlight_sysfs.path)

        assert backlight._denormalize_brightness(100) == 255
        assert backlight._denormalize_brightness(50) == 128
        assert backlight._denormalize_brightness(0) == 0
예제 #2
0
def test_constructor() -> None:
    with pytest.raises(TypeError):
        Backlight(board_type="foo")  # type: ignore[arg-type]

    assert not _EMULATOR_SYSFS_TMP_FILE_PATH.exists()
    with pytest.raises(RuntimeError):
        Backlight(backlight_sysfs_path=":emulator:")
예제 #3
0
    def __init__(self, rootPath):
        super().__init__()
        self.rootPath = rootPath
        self.__server = WebSocketServer(self)
        self.__server.start()
        self.__relay = PyRelay()
        self.__temp = PyTemp()
        self.__temp
        self.__temp.start()
        self.__stats_tab_index = 0
        self.__buttons_tab_index = 1
        self.enable_gui_switch = True
        self.timer = QTimer()
        self.timer.timeout.connect(self.__timer_tick)

        try:
            self.backlight = Backlight()
        except:
            self.fakeBacklightSysfs = FakeBacklightSysfs()
            self.fakeBacklightSysfs.__enter__()
            self.backlight = Backlight(
                backlight_sysfs_path=self.fakeBacklightSysfs.path)

        self.initUI()
        self.enable_screensaver()
예제 #4
0
def test_set_value() -> None:
    with FakeBacklightSysfs() as backlight_sysfs:
        backlight = Backlight(backlight_sysfs_path=backlight_sysfs.path)

        assert backlight._set_value(
            "brightness", 0) is None  # type: ignore[func-returns-value]
        assert backlight._get_value("brightness") == 0
예제 #5
0
def test_normalize_brightness() -> None:
    with FakeBacklightSysfs() as backlight_sysfs:
        backlight = Backlight(backlight_sysfs_path=backlight_sysfs.path)

        assert backlight._normalize_brightness(255) == 100
        assert backlight._normalize_brightness(128) == 50
        assert backlight._normalize_brightness(0) == 0
예제 #6
0
    def set_brighness_level(self, level):
        """
     Change screen brightness to value givin as parameter
    """

        backlight = Backlight()
        backlight.brightness = level
예제 #7
0
    async def resolve(self):
        sysfs_path = self.request_context.config.backlight_sysfs_path

        if not sysfs_path:
            return False

        backlight = Backlight(sysfs_path)

        with backlight.fade(self.args.fade_duration or 0):
            backlight.brightness = self.args.brightness

        return True
예제 #8
0
def test_fade() -> None:
    with FakeBacklightSysfs() as backlight_sysfs:
        backlight = Backlight(backlight_sysfs_path=backlight_sysfs.path)

        assert backlight.fade_duration == 0

        backlight.fade_duration = 0.1
        assert backlight.fade_duration == 0.1

        with backlight.fade(duration=0.5) as _val:
            assert _val is None
            assert backlight.fade_duration == 0.5

        assert backlight.fade_duration == 0.1
예제 #9
0
    def decrease_brightness(self, start_hour, finish_hour):
        print('start hour {}'.format(start_hour), flush=True)
        print('finish hour {}'.format(finish_hour), flush=True)
        print('decreasing brightness', flush=True)

        if finish_hour > start_hour:
            bl = Backlight()
            is_on = bl.power

            diff = finish_hour - start_hour

            half_hour_diff = diff * 2

            if is_on:
                print('is on', flush=True)
                brightness = 50
                for x in range(half_hour_diff):
                    print('brightness at {}'.format(brightness), flush=True)
                    if brightness < 10:
                        bl.power = False  # turn off the display
                    else:
                        if brightness == 10:
                            brightness = 11  # 11 is the min brightness
                        with bl.fade(duration=3):
                            bl.brightness = brightness
                        # bl.set_brightness(brightness, smooth=True, duration=3)
                        brightness = brightness - 10
                        print('sleeping 30 minutes...', flush=True)
                        time.sleep(60 * 30)
        elif finish_hour == start_hour:
            bl = Backlight()
            bl.power = False
        else:
            raise Exception(
                'the finish hour should be bigger than the start hour')
예제 #10
0
    async def _control(self):
        config = self._config.auto_backlight

        backlight = Backlight(self._config.backlight_sysfs_path)
        i2c = busio.I2C(board.SCL, board.SDA)
        veml7700 = adafruit_veml7700.VEML7700(i2c)
        backlight.fade_duration = config.fade_duration

        while True:
            light = veml7700.light
            rel_light = min(1, light / config.light_max)
            brightness = round(exponential_ease_out(min(1, rel_light)) * 100)
            limited_brightness = max(config.brightness_min, brightness)
            backlight.brightness = limited_brightness
            logger.debug("light: %s, rel_light: %s, brightness: %s, limited_brightness: %s", light, rel_light, brightness, limited_brightness)
            await asyncio.sleep(config.refresh)
예제 #11
0
    def __init__(self, config_path):
        # Load the configuration.
        self._config = configparser.ConfigParser()
        if len(self._config.read(config_path)) == 0:
            raise RuntimeError(
                'Failed to find configuration file at {0}, is the application properly installed?'
                .format(config_path))
        self._mqttbroker = self._config.get('mqtt', 'broker')
        self._mqttuser = self._config.get('mqtt', 'user')
        self._mqttpassword = self._config.get('mqtt', 'password')
        self._mqttconnectedflag = False
        self._mqtt_state_topic = self._config.get('mqtt', 'state_topic')
        self._mqtt_command_topic = self._config.get('mqtt', 'command_topic')
        self._mqtt_brightness_state_topic = self._config.get(
            'mqtt', 'brightness_state_topic')
        self._mqtt_brightness_command_topic = self._config.get(
            'mqtt', 'brightness_command_topic')
        self._mqtt_clientid = self._config.get('mqtt', 'clientid')
        self._console_output = self._config.getboolean('misc', 'debug')

        # initalise backlight object
        try:
            self._backlight = Backlight()
            self._backlight.fade_duration = self._config.getfloat(
                'backlight', 'fade_duration')
        except:
            self._print(
                "Could not initialise backlight component. Are you running this on a RPi?"
            )
            exit(1)
예제 #12
0
    def main_app(self):

        while True:

            try:

                bl = Backlight()

                now = pendulum.now()
                print('Current time is {0}'.format(
                    now.to_day_datetime_string()),
                      flush=True)

                difference = now.diff(self.last_check, False).in_hours()

                if difference > 10:
                    self.check_for_sunset_sunrise(day=now)

                hour = now.hour
                seconds_to_sleep = 600
                if self.wake_time is not None and self.sleep_time is not None:
                    if (now > self.wake_time) and (now < self.sleep_time):
                        print('It\'s time to wake up!', flush=True)
                        bl.power = True
                        bl.brightness = 50
                        # lets always sleep 10 minutes instead
                        # seconds_to_sleep = self.calculate_sleep_time_in_seconds(now_time=now, later_time=self.sleep_time)
                        print('program sleeping for {0} minutes'.format(
                            seconds_to_sleep / 60),
                              flush=True)

                    elif now >= self.sleep_time:
                        print('Night time!', flush=True)
                        self.decrease_brightness(hour, 22)
                        # we check for tomorrow instead of today
                        self.check_for_sunset_sunrise(day=now.add(days=1))
                        # lets always sleep 10 minutes instead
                        # seconds_to_sleep = self.calculate_sleep_time_in_seconds(now_time=now, later_time=self.wake_time)
                    print('Sleeping {0} seconds'.format(seconds_to_sleep),
                          flush=True)
                    time.sleep(seconds_to_sleep)
                else:
                    # re initialize because times are NONE
                    self.check_for_sunset_sunrise(day=now)

            except Exception as e:
                print('Error running main_app : {0}'.format(e))
예제 #13
0
 def __init__(self):
     self.contador = 0
     self.th1 = Thread(target=self.reader)
     self.th2 = Thread(target=self.counter)
     self.th1.start()
     self.th2.start()
     self.mut = Semaphore(1)
     self.back = Backlight()
예제 #14
0
    async def resolve(self):
        sysfs_path = self.request_context.config.backlight_sysfs_path

        if not sysfs_path:
            return 0

        backlight = Backlight(sysfs_path)
        return backlight.brightness
예제 #15
0
 def _set_brightness(self, brightness):
     try:
         disp_type = self._display_type
         if self._runtime_system.is_target_system:
             if disp_type == DISP_TYPE_WAVESHARE_5_LCD:
                 pwm_val = brightness * 10  # actually 1023 is max
                 pin = self._waveshare_brightness_pin
                 os.system("gpio -g pwm " + str(pin) + " " + str(pwm_val))
             elif disp_type == DISP_TYPE_RPI:
                 backlight = Backlight()
                 backlight.fade_duration = 0.5
                 backlight.brightness = brightness
             else:
                 os.system("vcgencmd display_power 0")
         # save set value
         self._brightness = brightness
     except Exception as error:
         self._logger.error(
             "Display: Cannot set display brightness to %i: %s", brightness,
             str(error))
예제 #16
0
    def __init__(self, backlight_sysfs_path: Path) -> None:
        QMainWindow.__init__(self)

        self.backlight = Backlight(backlight_sysfs_path)

        self.screenshot = QPixmap(get_image_path("raspbian.png"))
        self.image_display_on = load_display_image(
            get_image_path("display_on.png"))
        self.image_display_off = load_display_image(
            get_image_path("display_off.png"))

        widget = QWidget()
        checkbox_layout = QBoxLayout(QBoxLayout.LeftToRight)
        main_layout = QBoxLayout(QBoxLayout.TopToBottom)
        brightness_slider_label = QLabel("Brightness", widget)
        self.live_screen_checkbox = QCheckBox("Show live screen", widget)
        self.live_screen_checkbox.stateChanged.connect(self.update_screen)
        self.power_checkbox = QCheckBox("Power", widget)
        self.power_checkbox.stateChanged.connect(self.write_power_change)
        self.brightness_slider = QSlider(Qt.Horizontal, widget)
        self.brightness_slider.valueChanged.connect(
            self.write_brightness_change)
        self.brightness_slider.setSingleStep(1)
        self.brightness_slider.setMinimum(0)
        self.brightness_slider.setMaximum(100)
        self.screen_image = QLabel()
        checkbox_layout.addWidget(self.power_checkbox)
        checkbox_layout.addWidget(self.live_screen_checkbox)
        main_layout.addLayout(checkbox_layout)
        main_layout.addWidget(brightness_slider_label)
        main_layout.addWidget(self.brightness_slider)
        main_layout.addWidget(self.screen_image)
        widget.setLayout(main_layout)

        self.thread = FileWatcherThread(self, backlight_sysfs_path)
        self.thread.file_changed.connect(self.update_widgets)
        self.thread.start()

        self.timer = QTimer(self)
        self.timer.setInterval(100)
        self.timer.timeout.connect(self.update_screen)
        self.timer.start()

        self.update_widgets("bl_power")
        self.update_widgets("brightness")

        self.setCentralWidget(widget)
        self.setWindowTitle('Raspberry Pi 7" display backlight emulator')
        self.setWindowIcon(QIcon(get_image_path("icon.png")))
예제 #17
0
def test_set_brightness() -> None:
    with FakeBacklightSysfs() as backlight_sysfs:
        backlight = Backlight(backlight_sysfs_path=backlight_sysfs.path)

        backlight.brightness = 50
        assert backlight.brightness == 50

        backlight.brightness = 0
        assert backlight.brightness == 0

        with pytest.raises(TypeError):
            backlight.brightness = "foo"

        with pytest.raises(TypeError):
            backlight.brightness = True

        with pytest.raises(ValueError):
            backlight.brightness = 101

        with pytest.raises(ValueError):
            backlight.brightness = -1
예제 #18
0
def test_set_fade_duration() -> None:
    with FakeBacklightSysfs() as backlight_sysfs:
        backlight = Backlight(backlight_sysfs_path=backlight_sysfs.path)

        backlight.fade_duration = 0.5
        assert backlight.fade_duration == 0.5

        backlight.fade_duration = 1
        assert backlight.fade_duration == 1

        with pytest.raises(ValueError):
            backlight.fade_duration = -1

        with pytest.raises(TypeError):
            backlight.fade_duration = "foo"

        with pytest.raises(TypeError):
            backlight.fade_duration = True
예제 #19
0
def test_set_power() -> None:
    with FakeBacklightSysfs() as backlight_sysfs:
        backlight = Backlight(backlight_sysfs_path=backlight_sysfs.path)

        backlight.power = False
        assert backlight.power is False

        backlight.power = True
        assert backlight.power is True

        with pytest.raises(TypeError):
            backlight.power = "foo"

        with pytest.raises(TypeError):
            backlight.power = 1
예제 #20
0
def fadeTo(brightPercent, durationSeconds):
    backlight = Backlight()
    with backlight.fade(duration=durationSeconds):
        backlight.brightness = brightPercent
예제 #21
0
def openSettings():
    global settingsWindow
    global brightnessSlider
    global roomIdString
    global roomId
    global urlLabel
    settingsWindow = tk.Tk()
    settingsWindow.attributes("-fullscreen", True)
    settingsWindow.configure(bg="black")
    settingsWindow.columnconfigure(0, weight=3)
    settingsWindow.columnconfigure(1, weight=9)
    settingsWindow.columnconfigure(2, weight=4)
    settingsWindow.rowconfigure((0, 1, 2, 3, 4, 5, 6, 7), weight=1)

    brightnessLabel = tk.Label(settingsWindow,
                               bg="black",
                               fg="white",
                               font=mediumFontBold,
                               text="Brightness")
    brightnessLabel.grid(row=2, column=0)
    brightnessSlider = tk.Scale(settingsWindow,
                                from_=5,
                                to=100,
                                orient=tk.HORIZONTAL,
                                fg=blue,
                                bg="black",
                                bd=0,
                                highlightthickness=0,
                                font=smallFont,
                                width=40,
                                sliderrelief=tk.FLAT,
                                highlightcolor=blue,
                                command=changeBrightness)
    brightnessSlider.set(Backlight().brightness)
    brightnessSlider.grid(row=2, column=1, padx=10, sticky="NSEW")

    roomLabel = tk.Label(settingsWindow,
                         font=mediumFontBold,
                         fg="white",
                         bg="black",
                         text="Room ID")
    roomLabel.grid(row=4, column=0)
    roomIdString = tk.StringVar()
    roomId = tk.Entry(settingsWindow,
                      font=mediumFontBold,
                      textvariable=roomIdString)
    roomId.grid(row=4, column=1, sticky="EW", padx=10)

    urlLabel = tk.Label(settingsWindow, bg="black", fg="white", font=smallFont)
    urlLabel.grid(row=6, column=0, columnspan=2)
    updateRoomId()

    setBtn = tk.Button(settingsWindow,
                       text="Set",
                       bg=green,
                       activebackground=green,
                       fg="black",
                       relief=tk.FLAT,
                       font=mediumFont,
                       command=setRoomId)
    setBtn.grid(row=5, column=1)

    backBtn = tk.Button(settingsWindow,
                        text="Back",
                        bg=green,
                        activebackground=green,
                        relief=tk.FLAT,
                        font=mediumFont,
                        command=back)
    backBtn.grid(row=0, column=0, sticky="NW")

    updateBtn = tk.Button(settingsWindow,
                          text="Update",
                          bg=purple,
                          activebackground=purple,
                          relief=tk.FLAT,
                          font=largeFont,
                          command=update)
    updateBtn.grid(row=0, column=2, rowspan=2, sticky="NSEW")
    rebootBtn = tk.Button(settingsWindow,
                          text="Reboot",
                          bg=red,
                          activebackground=red,
                          relief=tk.FLAT,
                          font=largeFont,
                          command=reboot)
    rebootBtn.grid(row=6, column=2, rowspan=2, sticky="NSEW")
    shutDownBtn = tk.Button(settingsWindow,
                            text="Shut Down",
                            bg=red,
                            activebackground=red,
                            relief=tk.FLAT,
                            font=largeFont,
                            command=shutDown)
    shutDownBtn.grid(row=4, column=2, rowspan=2, sticky="NSEW")
    quitBtn = tk.Button(settingsWindow,
                        text="Quit",
                        bg=red,
                        activebackground=red,
                        relief=tk.FLAT,
                        font=largeFont,
                        command=close)
    quitBtn.grid(row=2, column=2, rowspan=2, sticky="NSEW")

    settingsWindow.mainloop()
예제 #22
0
def test_get_power() -> None:
    with FakeBacklightSysfs() as backlight_sysfs:
        backlight = Backlight(backlight_sysfs_path=backlight_sysfs.path)

        assert backlight.power is True
예제 #23
0
def test_get_fade_duration() -> None:
    with FakeBacklightSysfs() as backlight_sysfs:
        backlight = Backlight(backlight_sysfs_path=backlight_sysfs.path)

        assert backlight.fade_duration == 0
예제 #24
0
def test_get_brightness() -> None:
    with FakeBacklightSysfs() as backlight_sysfs:
        backlight = Backlight(backlight_sysfs_path=backlight_sysfs.path)

        assert backlight.brightness == 100
예제 #25
0
import socket
from rpi_backlight import Backlight
backlight =  Backlight()

UDP_IP = ''
UDP_PORT = 50007
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.bind((UDP_IP, UDP_PORT))

while True:
    data, addr = sock.recvfrom(1024)
    if data == b'display_on':
        backlight.power = True
    if data == b'display_off':
        backlight.power = False
    if data == b'display_low':
        backlight.brightness = 10 oder 25
    if data == b'display_medium':
        backlight.brightness = 30 oder 50
    if data == b'display_high':
        backlight.brightness = 100 oder 75
예제 #26
0
    def __init__(self, cfg: dict) -> None:
        super().__init__()

        bell_config = MqttStringConfig(**cfg['bell'])

        door_list = []
        for door, d_cfg in cfg['doors'].items():
            print(f"new_door: {door}")
            new_door = Door(door_id=door,
                            name=d_cfg['name'],
                            command_topic=d_cfg['command_topic'],
                            state_topic=d_cfg['state_topic'])
            # new_door.set_relay()
            door_list.append(new_door)

        doors_config = DoorsConfig(doors=door_list)

        print(cfg['garage'])

        garage_config = MqttStringConfig(**cfg['garage'])

        mode_config = MqttStringConfig(**cfg['mode'])

        self.kelvin = kelvin_rgb_to_kivy()
        self.azure = get_color_from_hex('#f0ffff')

        self.theme_cls = ThemeManager()
        self.theme_cls.primary_palette = "Blue"
        self.theme_cls.primary_hue = "500"
        self.theme_cls.accent_palette = "Yellow"
        self.theme_cls.accent_palette_hue = "500"
        self.theme_cls.theme_style = "Light"

        self.doors_config = doors_config
        self.bell_config = bell_config
        self.garage_config = garage_config
        self.mode_config = mode_config

        self.backlight = Backlight()

        ## GUI ##
        self.gui = ScreenManager(transition=NoTransition())
        try:
            self.screens = config.screens
        except AttributeError:
            self.screens = None
        else:
            for screen in self.screens:
                print(f'New screen: {screen}')
                try:
                    import_statemet = self.screens[screen][
                        "import"] + ' as NewScreen'
                    print(import_statemet)
                    exec(import_statemet)
                except Exception as e:
                    print(e)
                else:
                    screen_kwargs = {}
                    screen_kwargs.update({'name': screen})
                    # screen_kwargs.update({'controller':self})
                    # screen_kwargs.update({'sub':self.screens[screen].get("sub", None)})
                    # screen_kwargs.update({'memory':kwargs.get(screen,None)})

                    print(f'SCREEN NAME IS: {screen}')
                    print(f'with kwargs: {screen_kwargs}')

                    self.screens[screen]["object"] = eval('NewScreen')(
                        **screen_kwargs)

                    self.gui.add_widget(self.screens[screen]["object"])

        self.change_screen(self.gui.screen_names[0])
예제 #27
0
 def __init__(self):
     logger.debug('Initializing Backlight()')
     self.backlight = Backlight()
     logger.info('Backlight starting brightness is %d',
                 self.backlight.brightness)
예제 #28
0
def changeBrightness(event):
    brightness = brightnessSlider.get()
    Backlight().brightness = brightness
예제 #29
0
import glob
import sys
from ft5406 import Touchscreen, TS_PRESS, TS_RELEASE, TS_MOVE
from math import floor
from subprocess import call
from subprocess import check_output
import subprocess as SP
from rpi_backlight import Backlight

screenState = "/home/pi/pi-tablet_retropie/assets/currentDisplayMode"
PNGVIEWPATH = "/home/pi/pi-tablet_retropie/assets/pngview/"
ICONPATH = "/home/pi/pi-tablet_retropie/assets/icons"
brightLast = ""
volumeLast = ""
layerList = []
backlight = Backlight()


def read_and_emulate_mouse(event, touch):
    global startX
    global startY
    global startTime
    global shouldRun
    global brightLast
    global volumeLast
    global killid
    global layerList
    if event == TS_RELEASE:
        os.system("sudo kill " +
                  "$(ps aux | grep '[p]ngview' | awk '{print $2}')")
        layerList = []
예제 #30
0
def test_set_value() -> None:
    with FakeBacklightSysfs() as backlight_sysfs:
        backlight = Backlight(backlight_sysfs_path=backlight_sysfs.path)

        assert backlight._set_value("brightness", 0) is None
        assert backlight._get_value("brightness") == 0