Ich habe einen Dell U2515H über HDMI an eine nVidia-Karte angeschlossen.

Ich habe versucht, softMCCS und es hat gut funktioniert. Ich konnte die Helligkeit der Hintergrundbeleuchtung über die Software anpassen.

Dies sind die Steuercodes, die dieser Monitor anscheinend unterstützt:

New control value
Restore factory defaults
Restore luminance/contrast defaults
Restore color defaults
Luminance
Contrast
Select color preset
Red video gain
Green video gain
Blue video gain
Active control
Input source
Screen orientation
Horizontal frequency
Vertical frequency
Panel sub-pixel layout
Display technology type
Application enable key
Display controller type
Display firmware level
Power mode
Display application
VCP version
Manufacturer specific - 0xE0
Manufacturer specific - 0xE1
Manufacturer specific - 0xE2
Manufacturer specific - 0xF0
Manufacturer specific - 0xF1
Manufacturer specific - 0xF2
Manufacturer specific - 0xFD

Ich habe auch ein paar andere Werkzeuge ausgewertet:

• Dimmer - Dimmt die Hintergrundbeleuchtung nicht. Verwendet gefälschte software Dimmen.
• ScreenBright - Anscheinend verwendet DDC / CI, um die hintergrundbeleuchtung, wurde aber von der Website des Autors entfernt. Ich habe nicht versucht, es von einer dieser zwielichtigen Spiegelseiten herunterzuladen.
• Redshift-Fälscht es wie Dimmer.

Bearbeiten: Es stellt sich heraus, dass es eine einfach zu bedienende API zum Einstellen der Bildschirmhelligkeit in Windows gibt. Hier ist ein Beispielcode:

Monitor.h

#pragma once

#include <physicalmonitorenumerationapi.h>
#include <highlevelmonitorconfigurationapi.h>

#include <vector>

class Monitor
{
public:
    explicit Monitor(PHYSICAL_MONITOR pm);
    ~Monitor();

    bool brightnessSupported() const;

    int minimumBrightness() const;
    int maximumBrightness() const;
    int currentBrightness() const;

    void setCurrentBrightness(int b);
    // Set brightness from 0.0-1.0
    void setCurrentBrightnessFraction(double fraction);

private:
    bool mBrightnessSupported = false;

    int mMinimumBrightness = 0;
    int mMaximumBrightness = 0;
    int mCurrentBrightness = 0;
    PHYSICAL_MONITOR mPhysicalMonitor;
};

std::vector<Monitor> EnumerateMonitors();

Monitor.cpp

#include "stdafx.h"
#include "Monitor.h"

Monitor::Monitor(PHYSICAL_MONITOR pm) : mPhysicalMonitor(pm)
{
    DWORD dwMonitorCapabilities = 0;
    DWORD dwSupportedColorTemperatures = 0;
    BOOL bSuccess = GetMonitorCapabilities(mPhysicalMonitor.hPhysicalMonitor, &dwMonitorCapabilities, &dwSupportedColorTemperatures);

    if (bSuccess)
    {
        if (dwMonitorCapabilities & MC_CAPS_BRIGHTNESS)
        {
            // Get min and max brightness.
            DWORD dwMinimumBrightness = 0;
            DWORD dwMaximumBrightness = 0;
            DWORD dwCurrentBrightness = 0;
            bSuccess = GetMonitorBrightness(mPhysicalMonitor.hPhysicalMonitor, &dwMinimumBrightness, &dwCurrentBrightness, &dwMaximumBrightness);
            if (bSuccess)
            {
                mBrightnessSupported = true;
                mMinimumBrightness = dwMinimumBrightness;
                mMaximumBrightness = dwMaximumBrightness;
            }
        }
    }
}

Monitor::~Monitor()
{
}

bool Monitor::brightnessSupported() const
{
    return mBrightnessSupported;
}

int Monitor::minimumBrightness() const
{
    return mMinimumBrightness;
}

int Monitor::maximumBrightness() const
{
    return mMaximumBrightness;
}

int Monitor::currentBrightness() const
{
    if (!mBrightnessSupported)
        return -1;

    DWORD dwMinimumBrightness = 0;
    DWORD dwMaximumBrightness = 100;
    DWORD dwCurrentBrightness = 0;
    BOOL bSuccess = GetMonitorBrightness(mPhysicalMonitor.hPhysicalMonitor, &dwMinimumBrightness, &dwCurrentBrightness, &dwMaximumBrightness);
    if (bSuccess)
    {
        return dwCurrentBrightness;
    }
    return -1;
}

void Monitor::setCurrentBrightness(int b)
{
    if (!mBrightnessSupported)
        return;

    SetMonitorBrightness(mPhysicalMonitor.hPhysicalMonitor, b);
}

void Monitor::setCurrentBrightnessFraction(double fraction)
{
    if (!mBrightnessSupported)
        return;
    if (mMinimumBrightness >= mMaximumBrightness)
        return;
    setCurrentBrightness((mMaximumBrightness - mMinimumBrightness) * fraction + mMinimumBrightness);
}


BOOL CALLBACK MonitorEnumCallback(_In_ HMONITOR hMonitor, _In_ HDC hdcMonitor, _In_ LPRECT lprcMonitor, _In_ LPARAM dwData)
{
    std::vector<Monitor>* monitors = reinterpret_cast<std::vector<Monitor>*>(dwData);

    // Get the number of physical monitors.
    DWORD cPhysicalMonitors;
    BOOL bSuccess = GetNumberOfPhysicalMonitorsFromHMONITOR(hMonitor, &cPhysicalMonitors);

    LPPHYSICAL_MONITOR pPhysicalMonitors = NULL;
    if (bSuccess)
    {
        // Allocate the array of PHYSICAL_MONITOR structures.
        LPPHYSICAL_MONITOR pPhysicalMonitors = new PHYSICAL_MONITOR[cPhysicalMonitors];

        if (pPhysicalMonitors != NULL)
        {
            // Get the array.
            bSuccess = GetPhysicalMonitorsFromHMONITOR(hMonitor, cPhysicalMonitors, pPhysicalMonitors);

            // Use the monitor handles.
            for (unsigned int i = 0; i < cPhysicalMonitors; ++i)
            {
                monitors->push_back(Monitor(pPhysicalMonitors[i]));
            }
        }
    }
    // Return true to continue enumeration.
    return TRUE;
}

std::vector<Monitor> EnumerateMonitors()
{
    std::vector<Monitor> monitors;
    EnumDisplayMonitors(NULL, NULL, MonitorEnumCallback, reinterpret_cast<LPARAM>(&monitors));
    return monitors;
}

Verwenden Sie auf die offensichtliche Weise.

Es ist möglich, die Firmware-Einstellungen und die Konfiguration von Monitoren zu steuern, die DDC/CI unterstützen.

Dell bietet eine benutzerdefinierte Marken-Software mit dem Namen Dell Display Manager, entworfen von EnTech Taiwan, für den Einsatz mit ihren Monitoren. Es ist in erster Linie ein GUI-basiertes Dienstprogramm, bietet aber eine ziemlich umfassende Befehlszeilenfunktion. Die aktuelle version ist kompatibel mit Windows Vista - Windows 10. Es kann mit Displays von anderen Anbietern arbeiten, aber das war nicht bestätigen.

Die neueste Version der Software kann direkt von der offiziellen Website heruntergeladen werden.

Dell Display Manager -

Die folgenden Informationen werden aus dem des Programms über Informationen und einen Teil der Readme.txt Datei, die die Befehlszeilensyntax hervorhebt.

Über

Dell Display Manager -
Version 1.27.0.1792
Copyright (c) 2007-2016, EnTech Taiwan.

Lizenziert an Dell Inc.

Webseite: http://www.entechtaiwan.com
E-mail: [email protected]

Befehlssprache

Eine umfangreiche und flexible Befehlssprache wird über die befehlszeilen-und Befehlszeilenargumente können kombiniert werden. Gegebenenfalls kann eine bestimmte Anzeige angestrebt werden durch voranstellen des Befehls mit der Anzeigenummer, z. B.2:AutoSetup; Wenn keine Anzeigenummer angegeben ist, befehl wird sein auf die aktuell ausgewählte Anzeige angewendet oder auf alle Displays, je nach Bedarf. Befehle umfassen:

SetActiveInput [DVI2/HDMI/DP2,etc] - schaltet aktiven Eingang
RestoreFactoryDefaults - stellt Werkseinstellungen wieder her*
AutoSetup - führt ein Autosetup aus (nur analog)*
RestoreLevelDefaults - stellt Level-Defaults wieder her*
RestoreColorDefaults - stellt Farbvorgaben wieder her*
SetBrightnessLevel X - setzt Helligkeit auf X% (0-100)*
SetContrastLevel X - setzt Kontrast zu X% (0-100)*
SetNamedPreset [Movie/CAL1,etc] - ändert den voreingestellten Modus*
SetPowerMode [on/off] - stellt den Anzeigeleistungsmodus ein*
SetOptimalResolution - schaltet auf optimale Auflösung um
SaveProfile [Name] - einstellungen im benannten Profil speichern*
RestoreProfile [Name] - einstellungen aus benanntem Profil wiederherstellen*
DeleteProfile [Name] - benanntes Profil löschen
SetGridType [X] - ändert den einfachen Anordnungstyp in X
Rescan - rescans Display-Hardware
ForceReset - verbindet und rettet Display-Hardware
SetControl X Y - setzt Hex-Steuerelement X auf Hex-Wert Y
IncControl X Y - erhöht den Wert von Control X um Y
DecControl X Y - verringert den Wert von Control X um Y
Wait X - pause X Millisekunden
Exit - beendet das Programm

Einige dieser Befehle erfordern die Vertrautheit mit den MCCS Standard. Zum Beispiel auf Monitoren, die es unterstützen, die befehl zum Umschalten der OSD-Sprache auf Spanisch wäre SetControl CC 0A; um ein OSD freizuschalten, das versehentlich gesperrt SetControl CA 02.

Anweisungen können auf der Kommandozeile kombiniert werden und zugewiesen zu Standard-Windows-Verknüpfungen mit optionalen Hotkeys. Beispiel:

ddm.exe /RestoreLevelDefaults /2:SetContrastLevel 70

Würde zuerst die Standardwerte der Ebene auf allen Monitoren wiederherstellen und dann stellen Sie den Kontrast auf Monitor #2 auf 70% ein.

Hinweis: Wenn Sie nicht auf einen bestimmten Monitor ausgerichtet sind, werden oben, die mit einem Sternchen gekennzeichnet sind ( * ) gelten für alle monitore zur einfachen und einheitlichen Kontrolle über alle Mitglieder einer multi-monitor-matrix. Zum Beispiel, wenn ausgeführt auf einer Matrix von 16 identischen Monitoren, die Befehlszeile:

ddm.exe /SetNamedPreset Warm /SetBrightnessLevel 75

Würde alle 16 Monitore auf den Warm Preset Modus setzen, mit einem Helligkeit von 75%.

Ich habe das Programm "mControl" verwendet, das gut für mich funktioniert - mein Monitor ist Dell U2312HM:

MControl verwandelt einzelne und mehrere Monitorarrays in intelligente programmierbare Geräte, die dynamisch die Ausrichtung ändern, Strom sparen, Farbprofile wechseln und die Helligkeit anpassen, sodass Sie nicht mehr mit archaischen Tasten auf dem Display selbst durch obskure Menüs lernen und navigieren müssen.

Um dieses Programm herunterzuladen, müssen Sie "Grafiken und Monitor" finden Dienstprogramme "Abschnitt auf der unteren Hälfte der Seite http://www.ddc-ci.com/, und klicken Sie unten in diesem Abschnitt auf den Link "mControl".

Ich benutze dieses Autohotkey-Skript, inspiriert von this reddit post, um die entsprechenden MCCS-Befehle zu senden. Funktioniert wie ein Zauber auf meinem Dell U2718Q unter Win10:

^!-::
    changeMonitorBrightness(-10)
return

^!=::
    changeMonitorBrightness(10)

getMonitorHandle()
{
  MouseGetPos, xpos, ypos
  point := ( ( xpos ) & 0xFFFFFFFF ) | ( ( ypos ) << 32 )
  ; Initialize Monitor handle
  hMon := DllCall("MonitorFromPoint"
    , "int64", point ; point on monitor
    , "uint", 1) ; flag to return primary monitor on failure

  ; Get Physical Monitor from handle
  VarSetCapacity(Physical_Monitor, 8 + 256, 0)

  DllCall("dxva2\GetPhysicalMonitorsFromHMONITOR"
    , "int", hMon   ; monitor handle
    , "uint", 1   ; monitor array size
    , "int", &Physical_Monitor)   ; point to array with monitor

  return hPhysMon := NumGet(Physical_Monitor)
}

destroyMonitorHandle(handle)
{
  DllCall("dxva2\DestroyPhysicalMonitor", "int", handle)
}


changeMonitorBrightness(delta)
{
  vcpLuminance := 0x10

  handle := getMonitorHandle()

  DllCall("dxva2\GetVCPFeatureAndVCPFeatureReply"
    , "int", handle
    , "char", vcpLuminance
    , "Ptr", 0
    , "uint*", luminance
    , "uint*", maximumValue)

  luminance += delta

  if (luminance > 100) 
  {
  luminance := 100
  }
  else if (luminance < 0)
  {
  luminance := 0
  }

  DllCall("dxva2\SetVCPFeature"
    , "int", handle
    , "char", vcpLuminance
    , "uint", luminance)
  destroyMonitorHandle(handle)
} 

Für diejenigen, die für Mac OS X hierher kommen, schauen Sie sich dieses erstaunliche Projekt an: https://lunar.zu Ihrer Information / Es hat bei mir funktioniert und es eigentlich die Helligkeit des externen Monitors wurde nicht nur in der Software angepasst.

Ich fand https://github.com/MonitorControl/MonitorControl für Mac. Funktioniert wie ein Zauber!

Für Windows habe ich gefunden https://github.com/emoacht/Monitorian .