class Backend(): def __init__(self, settings : dict): ip = "127.0.0.1" port = 6742 retry_sleep = 5 retries = 3 if settings: ip = settings.get("ip_address", ip) port = settings.get("port", port) retry_sleep = settings.get("retry_sleep", retry_sleep) retries = settings.get("retries", retries) logger.info("Using OpenRGB backend at {}:{}".format(ip, port)) while not hasattr(self, "client") and retries > 0: try: logger.debug("Trying to connect to OpenRGB server") self.client = OpenRGBClient(ip, port, name="RGBmon") except ConnectionRefusedError as e: logger.warning("Could not connect to OpenRGB server: {}".format(e)) retries -= 1 if not retries > 0: raise time.sleep(retry_sleep) def get_led_list(self, config : dict) -> List[openrgb.orgb.LED]: led_config = config["leds"] led_list = [] logger.debug("Retrieving led list from OpenRGB backend") for led_entry in led_config: device_type = get_device_type(led_entry["type"]) devices = self.client.get_devices_by_type(DeviceType(device_type)) device_list = list(map(create_device, range(len(devices)))) if "devices" in led_entry: device_list = led_entry["devices"] for device in device_list: # Get the device device_id = device["id"] orgb_device = devices[device_id] # Set the target mode orgb_device.set_mode(led_entry["mode"]) # Check if it requires specific zones and add LEDs if "zones" in device: for zone_id in device["zones"]: led_list.extend(reversed(orgb_device.zones[zone_id].leds)) else: led_list.extend(reversed(orgb_device.leds)) if not led_list: logger.warning("Could not find any LEDs for backend request.") return led_list def apply(self, leds_colors : List[Tuple[int, openrgb.orgb.LED]]): for led, color in leds_colors: r, g, b = color led.set_color(RGBColor(r, g, b), fast=True)
def initRGB(): # Getting this script ready to be run as a service. Waiting for the sdk to start. while True: try: print("trying to connect") cli = OpenRGBClient() break except ConnectionRefusedError: sleep(5) continue try: cooler = cli.get_devices_by_type(DeviceType.COOLER)[0] except IndexError: cooler = False try: gpu = cli.get_devices_by_type(DeviceType.GPU)[0] except IndexError: gpu = False # right_ram, left_ram = cli.get_devices_by_type(DeviceType.DRAM) # right_ram.clear() # left_ram.clear() # To make sure the devices are in the right mode, and to work around a problem # where the gpu won't change colors until switched out of static mode and # then back into static mode. if cooler: cooler.set_mode(0) # Direct mode if gpu: gpu.set_mode(1) # Anything would work, this is breathing in my setup sleep(.1) gpu.set_mode(0) # Static mode. My GPU doesn't have a direct mode. try: nvmlInit() handle = nvmlDeviceGetHandleByIndex(0) except: gpu, handle = False, False else: handle = False return cooler, gpu, handle
def initRGB(): global keyb global cli global keyboard_leds global keyboard_zone global led_count cli = OpenRGBClient() print(cli) keyb = cli.get_devices_by_type(DeviceType.KEYBOARD)[0] print(keyb) keyb.set_mode('direct') keyboard_leds = keyb.zones[0].leds led_count = len(keyboard_leds) keyboard_zone = keyb.zones[0] print(f'Keyboard Zone Type: {keyboard_zone.type}') #assert keyboard_zone.type == ZoneType.LINEAR return keyboard_leds
#!/usr/bin/env python3 from openrgb import OpenRGBClient from openrgb.utils import RGBColor, DeviceType import psutil client = OpenRGBClient() cooler = client.get_devices_by_type(DeviceType.COOLER)[0] cpu_led = cooler.zones[2].leds[0] while True: current_temp = int(psutil.sensors_temperatures()['k10temp'][-1].current) min_temp = 35 max_temp = 65 min_hue = 0 #Red max_hue = 120 #Green step = max_hue / (max_temp - min_temp) offset = current_temp - min_temp current_hue = max_hue - (offset * step) if current_hue < min_hue: current_hue = min_hue cpu_led.set_color(RGBColor.fromHSV(current_hue, 100, 100))
@author: Bharath """ from Asus_argb_ambient_lighting import get_split_screen_colors # https://openrgb-python.readthedocs.io/en/latest/pages/advanced.html from openrgb import OpenRGBClient from openrgb.utils import RGBColor, DeviceType import numpy as np import time client = OpenRGBClient() client.clear() # Turns everything off motherboard = client.get_devices_by_type(DeviceType.MOTHERBOARD)[0] add = client.get_devices_by_type(DeviceType.MOTHERBOARD)[1] add.leds[20].set_color(RGBColor(0, 255, 0)) cols = [] nleds = 41 split_cols = get_split_screen_colors() EN = [0, 5] ES = [5, 10] SE = [10, 16] SW = [16, 21] WS = [21, 26] WN = [26, 32] NW = [32, 37]
class OpenRGBNvim(object): """interface with OpenRGB""" def __init__(self, vim): self.vim = vim self.port = 6742 self.device_type = DeviceType.KEYBOARD self.is_connected = False self.connection_failed = False self.led_names = [] self.prev_vim_mode = '' self.th_cnt = 0 # vim variables self.vim.vars['openrgb_connection_failed'] = False self.vim.vars['openrgb_led_names'] = [] self.mode_dict = self.vim.vars['openrgb_mode_dict'] def vim_color_to_rgb(self, vim_color): r = eval("0x" + vim_color[1:3]) g = eval("0x" + vim_color[3:5]) b = eval("0x" + vim_color[5:7]) return (r, g, b) def vim_color_to_rgb_color(self, vim_color): return RGBColor(*self.vim_color_to_rgb(vim_color)) def get_complementary_rgb_colors(self, vim_color, nb_colors): crgbs = [] (r, g, b) = self.vim_color_to_rgb(vim_color) (h, s, v) = colorsys.rgb_to_hsv(r, g, b) cs = max(s, 0.7) cv = max(v, 128) for i in range(nb_colors): j = i - 1 if j < 0: delta = 0 else: h_step = 0.25 / (nb_colors // 2) sign = (-1, 1)[j % 2] delta = sign * ((j // 2) + 1) * h_step ch = (h + 0.5 + delta) % 1.0 (cr, cg, cb) = (int(x) for x in colorsys.hsv_to_rgb(ch, cs, cv)) crgbs.append(RGBColor(cr, cg, cb)) return crgbs def led_names_to_ids(self, names): ids = [] for name in names: ids.append(self.led_names.index(name)) return ids def connect(self): if self.connection_failed or self.is_connected: return try: self.client = OpenRGBClient(port=self.port) self.device = self.client.get_devices_by_type(self.device_type)[0] self.led_names = [ self.device.data.leds[x].name for x in range(len(self.device.data.leds)) ] self.is_connected = True self.vim.vars['openrgb_led_names'] = self.led_names except: self.connection_failed = True self.vim.vars['openrgb_connection_failed'] = True self.vim.command( 'echom "[vim-openrgb] cannot connect to openrgb server"') @pynvim.function('OpenRGBSync', sync=True) def sync(self, args): pass @pynvim.function('OpenRGBChangeColor') def change_color(self, args): self.th_cnt += 1 my_th_cnt = self.th_cnt vim_color = args[0] led_names = args[1] if len(args) > 1 else [[]] led_vim_colors = args[2] if len(args) > 2 else [] force = args[3] if len(args) > 3 else False # fill led_rgb_colors led_rgb_colors = [] if len(led_names): if len(led_vim_colors): led_rgb_colors = [ self.vim_color_to_rgb_color(vim_color) for vim_color in led_vim_colors ] else: # choose led_rgb_colors automatically led_rgb_colors = self.get_complementary_rgb_colors( vim_color, len(led_names)) self.connect() if self.is_connected: # main color rgb_color = self.vim_color_to_rgb_color(vim_color) for c in range(len(self.device.colors)): self.device.colors[c] = rgb_color # led colors for i, rgb_color in enumerate(led_rgb_colors): for c in self.led_names_to_ids(led_names[i]): self.device.colors[c] = rgb_color # show only most recent thread if my_th_cnt >= self.th_cnt: self.device.show(fast=True, force=force) self.th_cnt -= 1 @pynvim.function('OpenRGBChangeColorFromMode') def change_color_from_mode(self, args): vim_mode = args[0] force = args[1] if len(args) > 1 else False if not force and vim_mode == self.prev_vim_mode: return self.prev_vim_mode = vim_mode d = self.mode_dict.get(vim_mode, self.mode_dict['default']) self.change_color( [d['main_color'], d['led_names'], d['led_colors'], force])
maxtemp = 100 mintemp = 30 maxperf = 125 minperf = 95 ledstripsize = 19 red = RGBColor(255, 0, 0) blue = RGBColor(0, 0, 255) zonenumber = 0 #myColorList = red, blue, red, blue, red, blue, red, red, blue, blue, red, blue, red, blue cli = OpenRGBClient() print(cli) mobo = cli.get_devices_by_type(DeviceType.MOTHERBOARD)[0] print(mobo) mobo.set_mode('direct') mobo.zones[zonenumber].resize(ledstripsize) print(mobo.zones[zonenumber]) myLeds = mobo.zones[zonenumber].leds for i in myLeds: i.set_color(red) step = ((maxperf - minperf) / len(myLeds)) while True: procperf = winstats.get_perf_data( r'\Processor Information(_Total)\% Processor Performance', fmts='double',
#!/usr/bin/env python3 from openrgb import OpenRGBClient from openrgb.utils import RGBColor, DeviceType, ZoneType from time import sleep cli = OpenRGBClient() keyboard = cli.get_devices_by_type(DeviceType.KEYBOARD)[0] keys_zone = [z for z in keyboard.zones if z.type == ZoneType.MATRIX][0] while True: for color in (RGBColor(255, 0, 0), RGBColor(0, 255, 0), RGBColor(0, 0, 255), RGBColor(0, 0, 0)): for x in range(len(keys_zone.leds)): keys_zone.set_color(color, end=(x + 1)) sleep(.3)
def setMode(devices: list[Device], mode: str): for device in devices: device.set_mode(mode) def setColor(devices: list[Device], color: RGBColor): for device in devices: device.set_color(color) if len(sys.argv) < 2: sys.exit(1) client = OpenRGBClient() dram = client.get_devices_by_type(DeviceType.DRAM) mobo_led = client.get_devices_by_type(DeviceType.MOTHERBOARD) if sys.argv[1] == "off": setMode(dram, "off") setMode(mobo_led, "off") elif sys.argv[1] == "on": setMode(dram, "rainbow") setMode(mobo_led, "rainbow") elif sys.argv[1] == "dim": color = RGBColor(75, 10, 140) setMode(dram, "breathing") setMode(mobo_led, "direct") setColor(dram, color) setColor(mobo_led, color)
def loop(interval: float, mod_aura: int): """ Sets cooler color in a loop. Takes time of day and CPU temperature into account. :param interval: Time between cycles in seconds. :param mod_aura: How many kraken cycles pass between each aura cycle. :return: """ # init sensors sensors.init() # init openrgb client client = OpenRGBClient() kraken = client.get_devices_by_type( DeviceType.LEDSTRIP)[0] # weird type for a COOLER, I know ring = kraken.zones[1] logo = kraken.zones[2] aura = client.get_devices_by_type(DeviceType.MOTHERBOARD)[0] aura.zones[1].resize(120) # count kraken cycles count = 0 while True: # calculate ring color based on CPU temperature ring_hex_color = get_color() r, g, b = hex_to_rgb(ring_hex_color) # calculate brightness brightness = get_kraken_brightness() # apply brightness r *= brightness g *= brightness b *= brightness # round to int r, g, b = validate_color(r, g, b) # set kraken ring color ring.set_color(RGBColor(r, g, b)) # read logo color logo_hex_color = KRAKEN_LOGO_COLOR r, g, b = hex_to_rgb(logo_hex_color) # calculate logo brightness brightness = get_kraken_brightness() # apply brightness r *= brightness g *= brightness b *= brightness # round to int r, g, b = validate_color(r, g, b) # set logo color logo.set_color(RGBColor(r, g, b)) # set aura color if needed if count % mod_aura == 0: set_aura_color(aura) count = 0 # sleep for a predefined amount of time if interval < 0: return time.sleep(interval) count += 1
#!/usr/bin/env python3 from openrgb import OpenRGBClient from openrgb.utils import RGBColor, DeviceType, ZoneType from time import sleep cli = OpenRGBClient() keyboard = cli.get_devices_by_type(DeviceType.DEVICE_TYPE_KEYBOARD)[0] keys_zone = [z for z in keyboard.zones if z.type == ZoneType.ZONE_TYPE_MATRIX][0] try: keyboard.set_mode("direct") except: keyboard.set_mode(0) while True: for color in (RGBColor(255, 0, 0), RGBColor(0, 255, 0), RGBColor(0, 0, 255), RGBColor(0, 0, 0)): for x in range(len(keys_zone.leds)): keys_zone.set_color(color, end=(x + 1)) sleep(.3)
#!/usr/bin/env python3 from openrgb import OpenRGBClient from openrgb.utils import RGBColor, DeviceType import sensors from time import sleep from py3nvml.py3nvml import nvmlInit, nvmlDeviceGetHandleByIndex, nvmlDeviceGetTemperature, NVML_TEMPERATURE_GPU # import psutil cli = OpenRGBClient() nvmlInit() cooler = cli.get_devices_by_type(DeviceType.DEVICE_TYPE_COOLER)[0] gpu = cli.get_devices_by_type(DeviceType.DEVICE_TYPE_GPU)[0] # right_ram, left_ram = cli.get_devices_by_type(DeviceType.DEVICE_TYPE_DRAM) handle = nvmlDeviceGetHandleByIndex(0) def temp_to_color(temp: int) -> (int, int): if temp < 40: return 0, 255 elif temp < 70: return int((temp - 40) * 8), int((70 - temp) * 8) elif temp >= 70: return 255, 0 # right_ram.clear() # left_ram.clear() try:
from random import randrange from typing import List from openrgb import OpenRGBClient from openrgb.utils import DeviceType from colors import * # need to provide LED_SIZE = 24 client = OpenRGBClient() client.clear() # Turns everything off motherboard = client.get_devices_by_type(DeviceType.MOTHERBOARD)[0] motherboard.zones[1].resize(LED_SIZE) keyboard = client.get_devices_by_type(DeviceType.KEYBOARD)[0].zones[0] KEYBOARD_SIZE = len(keyboard.colors) class Effects(object): @staticmethod def rainbow(): motherboard.set_mode('Rainbow') @staticmethod def spectrum(): motherboard.set_mode('Spectrum Cycle')
#!/usr/bin/env python3 from openrgb import OpenRGBClient from openrgb.utils import RGBColor, DeviceType import psutil client = OpenRGBClient() ram = client.get_devices_by_type(DeviceType.DRAM) while True: ram_use = int(psutil.virtual_memory()[2]) loops = int((ram_use / 20) + 1) colour = 5 - loops for i in range(4, -1, -1): if loops > 0: ram[1].leds[x].set_color(RGBColor.fromHSV(colour * 24, 100, 100)) ram[3].leds[x].set_color(RGBColor.fromHSV(colour * 24, 100, 100)) ram[0].leds[x].set_color(RGBColor.fromHSV(colour * 24, 100, 100)) ram[2].leds[x].set_color(RGBColor.fromHSV(colour * 24, 100, 100)) else: ram[1].leds[x].set_color(RGBColor(0, 0, 0)) ram[3].leds[x].set_color(RGBColor(0, 0, 0)) ram[0].leds[x].set_color(RGBColor(0, 0, 0)) ram[2].leds[x].set_color(RGBColor(0, 0, 0)) loops = loops - 1