Wie kann ich eine richtlinienerzwungene Bildschirmsperre in Windows verhindern?

Wenn Windows Media Player noch installiert ist, können Sie ein Video in einer Schleife abspielen und minimieren (die Beispielvideos für "Wildlife" funktionieren einwandfrei). Standardmäßig wird der Bildschirm nicht gesperrt, solange ein Video abgespielt wird.

Ich benutze ein Skript, das ich im Leerlauf habe.vbs:

Dim objResult

Set objShell = WScript.CreateObject("WScript.Shell")    

Do While True
  objResult = objShell.sendkeys("{NUMLOCK}{NUMLOCK}")
  Wscript.Sleep (6000)
Loop

Alle sechs Sekunden schaltet dies Numlock auf der Tastatur schnell um, wodurch Windows glaubt, dass jemand mit der Tastatur interagiert, wodurch die Bildschirmsperre verhindert wird. Dies läuft unter Vanilla Windows, Sie benötigen keine Entwicklungs-oder Skriptwerkzeuge, um es zu verwenden, sondern erstellen Sie einfach eine Textdatei mit .vbs als Erweiterung und doppelklicken Sie darauf (oder platzieren Sie es in Ihren Startelementen).

Bearbeiten: Sie können dieses Skript in Ihre Startelemente einfügen mit

 choco install IdleVbs -source https://www.myget.org/F/joshrivers-utility/

Weitere Informationen zum Choclatey (choco) CLI Installer finden Sie unter:

Https://chocolatey.org/

Sie können ein AutoIt - Skript erstellen, um entweder kontinuierlich eine nicht verwendete Taste zu drücken (z. B. die Num-Sperre umschalten, Scroll-Sperre), eine Minute oder so zu schlafen und zu wiederholen. Wenn Sie die Tastatur häufig verwenden, können Sie die Maus alternativ um ein Pixel in eine beliebige Richtung bewegen.

Wenn Sie nicht möchten, dass es kontinuierlich ausgeführt wird, können Sie das Skript auch als geplante Aufgabe starten (falls Sie Zugriff haben), die gestartet wird, nachdem der Computer einige Zeit inaktiv war.

Und dies ist ein sehr einfaches Skript, um eine unsichtbare Mausbewegung auszuführen, wenn Sie nicht in die AutoIt-Syntax einsteigen möchten:

While True
   Local $pos = MouseGetPos()
   MouseMove($pos[0]-1, $pos[1]-1, 0)
   MouseMove($pos[0], $pos[1], 0)
   Sleep(540000)
WEnd

Dieses Skript bewegt den Mauszeiger um ein Pixel nach oben links und gibt ihn danach zurück und schläft dann 9 Minuten (540000 Millisekunden). Wenn das Skript ausgeführt wird, können Sie das AutoIt-Symbol in der Taskleiste sehen. Sie können es stoppen, indem Sie mit der rechten Maustaste auf dieses Symbol klicken und die entsprechende Option auswählen.

Um ein Skript zu erstellen, installieren Sie AutoIt, klicken Sie mit der rechten Maustaste in einen beliebigen Ordner und wählen New > AutoIt v3 Script, benennen Sie es, klicken Sie mit der rechten Maustaste auf dieses neue Skript, wählen Sie Edit, fügen Sie den oben angegebenen Code ein und speichern Sie. Sie können es sogar in .exe kompilieren (erneut über das Kontextmenü), um beispielsweise über den Windows-Scheduler zu starten.

Es gibt eine Android-App namens "Timeout Blocker", die in einem Intervall vibriert und Sie können Ihre Maus darauf setzen. Es heißt jedoch, es nicht bei der Arbeit zu verwenden. https://play.google.com/store/apps/details?id=com.isomerprogramming.application.timeoutblocker&hl=en

Kompilieren Sie dies in Visual Studio oder C# Express und führen Sie es über eine Eingabeaufforderung aus (oder doppelklicken Sie darauf). Erfordert. NET 4.0 oder höher. Es tut alles, was Sie suchen.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.Threading;
using System.Runtime.InteropServices;
using System.Windows.Forms; 

namespace ImWorkin
{
    class Program
    {
        [FlagsAttribute]
        public enum EXECUTION_STATE : uint
        {
            ES_SYSTEM_REQUIRED = 0x00000001,
            ES_DISPLAY_REQUIRED = 0x00000002,
            ES_CONTINUOUS = 0x80000000
        }
        public SYSTEMTIMEOUTS TimeOuts
        {
            get { return sysTimeouts; }
        }
        public struct SYSTEMTIMEOUTS
        {
            public int BATTERYIDLETIMEOUT;
            public int EXTERNALIDLETIMEOUT;
            public int WAKEUPIDLETIMEOUT;
        }

        [DllImport("USER32.DLL", CharSet = CharSet.Unicode)]
        public static extern IntPtr FindWindow(string lpClassName, string lpWindowName);

        [DllImport("USER32.DLL")]
        public static extern bool SetForegroundWindow(IntPtr hWnd);

        [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        static extern EXECUTION_STATE SetThreadExecutionState(EXECUTION_STATE flags);

        [DllImport("user32.dll", SetLastError = true, EntryPoint ="SystemParametersInfo")]
        internal static extern int SystemParametersInfo(int uiAction, int uiParam, ref int pvParam, int fWinIni);

        private static System.Threading.Timer preventSleepTimer = null;
        public const int SPI_GETBATTERYIDLETIMEOUT = 252;
        public const int SPI_GETEXTERNALIDLETIMEOUT = 254;
        public const int SPI_GETWAKEUPIDLETIMEOUT = 256;
        public static int Counter = 0;
        public static int timeOutinMS = 0;
        public static int batteryIdleTimer;
        public static int externalIdleTimer;
        public static int wakeupIdleTimer;
        public static SYSTEMTIMEOUTS sysTimeouts;


        static void Main(string[] args)
        {
            Console.WriteLine("You are about to be workin!! Just a moment...I need to calculate a few values.");
            string dots = string.Empty;
            for (int i =2; i < 60; i++)
            {
                dots = "";
                for (int ii = 0; ii < i; ii++)
                {
                    dots = dots + ".";
                }
                Thread.Sleep(100);
                Console.Clear();
                Console.WriteLine("You are about to be workin!! Just a moment...I need to calculate a few values.");
                Console.WriteLine(dots);
            }


            GetSystemTimeOuts();


            if (timeOutinMS < sysTimeouts.BATTERYIDLETIMEOUT)
                timeOutinMS = sysTimeouts.BATTERYIDLETIMEOUT;
            if (timeOutinMS < sysTimeouts.EXTERNALIDLETIMEOUT)
                timeOutinMS = sysTimeouts.EXTERNALIDLETIMEOUT;
            if (timeOutinMS < sysTimeouts.WAKEUPIDLETIMEOUT)
                timeOutinMS = sysTimeouts.WAKEUPIDLETIMEOUT;

            if (timeOutinMS == 0)
                timeOutinMS = 30;

            DisableDeviceSleep();
            Console.WriteLine("");
            Console.WriteLine("");
            Console.WriteLine("OK. I have calculated your computers timeout periods and set the   ");
            Console.WriteLine("necessary hooks. Your computer will not shut off the monitor, will");
            Console.WriteLine("show active in any chat programs,the screensaver is disabled and ");
            Console.WriteLine("the computer will not lock! Anyone looking at you eaither locally ");
            Console.WriteLine("or remotely will think you are hard at work.");
            Console.WriteLine("");
            Console.WriteLine("Now go do something fun...I got your back ;)");
            Console.WriteLine("Oh yeah....if you close this window OR press `q' in this ");
            Console.WriteLine("window you are going to have to actually work.");
            Console.WriteLine("");
            Console.WriteLine("");
            Console.WriteLine("This text will disappear in a 30 seconds. Just in case someone comes ");
            Console.WriteLine("by and reads your screen!");
            Console.WriteLine("");
            Console.WriteLine("");
            Console.WriteLine("Need custom coding? [email protected]");
            while (Console.KeyAvailable == false)
            {
                Thread.Sleep(250);
                ConsoleKeyInfo cki = Console.ReadKey(true);

                if (cki.KeyChar == 'q')
                    break;
            }

        }


        public static void DisableDeviceSleep()
        {
           SetThreadExecutionState(EXECUTION_STATE.ES_SYSTEM_REQUIRED | EXECUTION_STATE.ES_DISPLAY_REQUIRED | EXECUTION_STATE.ES_CONTINUOUS);
           preventSleepTimer = new System.Threading.Timer(new TimerCallback(PokeDeviceToKeepAwake), null, 0, timeOutinMS * 1000);
        }

        public static void EnableDeviceSleep()
        {

           preventSleepTimer.Dispose();
           preventSleepTimer = null;

        }

        private static void PokeDeviceToKeepAwake(object extra)
        {

            Counter++;
            try
            {
                   SetThreadExecutionState(EXECUTION_STATE.ES_SYSTEM_REQUIRED | EXECUTION_STATE.ES_DISPLAY_REQUIRED | EXECUTION_STATE.ES_CONTINUOUS);
                   IntPtr Handle = FindWindow("SysListView32", "FolderView");

                   if (Handle == IntPtr.Zero)
                   {
                       SetForegroundWindow(Handle);
                       SendKeys.SendWait("%1");
                   }

                   if (Counter > 1)
                       Console.Clear();
            } 
            catch 
            {

            }
        }

        public static void GetSystemTimeOuts()  
        {
            sysTimeouts.BATTERYIDLETIMEOUT = -2;
            sysTimeouts.EXTERNALIDLETIMEOUT = -2;
            sysTimeouts.WAKEUPIDLETIMEOUT = -2;


            if (SystemParametersInfo(SPI_GETBATTERYIDLETIMEOUT, 0, ref batteryIdleTimer, 0) == 1)
                sysTimeouts.BATTERYIDLETIMEOUT = batteryIdleTimer;
            else
                sysTimeouts.BATTERYIDLETIMEOUT = -1;

            if (SystemParametersInfo(SPI_GETEXTERNALIDLETIMEOUT, 0, ref externalIdleTimer, 0) == 1)
                sysTimeouts.EXTERNALIDLETIMEOUT = externalIdleTimer;
            else
                sysTimeouts.EXTERNALIDLETIMEOUT = -1;



            if (SystemParametersInfo(SPI_GETWAKEUPIDLETIMEOUT, 0, ref wakeupIdleTimer, 0) == 1)
                sysTimeouts.WAKEUPIDLETIMEOUT = wakeupIdleTimer;
            else
                sysTimeouts.WAKEUPIDLETIMEOUT = -1;


        }
    }
}

Ich benutze gerne easy und integrierte Optionen (keine zusätzliche Software), wie ein Powershell-Skript (danke https://dmitrysotnikov.wordpress.com/2009/06/29/prevent-desktop-lock-or-screensaver-with-powershell/) , die die "f15" als Schlüssel zum Erfolg verwendet (thx zu Koffein. Es ist in der Tat am wenigsten störend)

param($minutes = 180)

write "... screen will be awake for $minutes"

 $myshell = New-Object -com "Wscript.Shell"

 for ($i = 0; $i -lt $minutes; $i++) {
 write "... screen will be awake for" ($minutes-$i)
 Start-Sleep -Seconds 60    
 $myshell.sendkeys("{F15}")
}

Setzen Sie dies in eine myScriptName.ps1 und starten Sie es über Desktop-Verknüpfung oder Befehlszeile: C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe -nop "C:\Users\myUser\Desktop\myScriptName.ps1"

UPDATE: Vielleicht gab es einige Änderungen vom Administrator, aber das funktioniert bei mir nicht mehr Jetzt muss ich ein Autohotkey-Skript von NBirnel verwenden: https://github.com/nbirnel/nosleep - diese Arbeit perfekt, weil es die Maus bewegt (ohne Ablenkung jede Arbeit)

Viele dieser Antworten sind alt und bleiben nur durch Eingaben/Mausbewegungen am Leben. Kompilieren Sie dies in C oder C++, dies hält die Sitzung am Leben, indem Sie den Thread-Ausführungsstatus festlegen (nur Windows natürlich)

#include <windows.h>

//https://docs.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-setthreadexecutionstate

#define ES_CONTINUOUS       0x80000000
#define ES_DISPLAY_REQUIRED 0x00000002
#define ES_SYSTEM_REQUIRED  0x00000001

int main()
{
    int result = 0;
    while(1)
    {
        result = SetThreadExecutionState(ES_SYSTEM_REQUIRED | ES_DISPLAY_REQUIRED | ES_CONTINUOUS);
        Sleep(30 * 1000);
    }

    //unreachable
    return 0;

}

Maus Jiggler könnte eine Option sein: https://mousejiggler.codeplex.com/

Sich auf Cherona's Antwort, hier ist eine Implementierung in PowerShell, mit SetThreadExecutionState().

Solange das Skript ausgeführt wird, werden Bildschirmschoner und Bildschirmsperre nicht gestartet.

Set-StrictMode -version 3.0

# Definition of SetThreadExecutionState from -
#   http://www.pinvoke.net/default.aspx/kernel32/SetThreadExecutionState.html
#   https://docs.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-setthreadexecutionstate
# "EXECUTION_STATE" changed to "uint", added "public" modifier.
$Signature = @'
[DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
public static extern uint SetThreadExecutionState(uint esFlags);
'@

$ES_AWAYMODE_REQUIRED = 0x00000040L
$ES_CONTINUOUS        = 0x80000000L
$ES_DISPLAY_REQUIRED  = 0x00000002L
$ES_SYSTEM_REQUIRED   = 0x00000001L

# Details on Add-Type in https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.utility/add-type?view=powershell-7.
$Kernel32 = Add-Type -MemberDefinition $Signature -Name 'Kernel32' -Namespace 'Kernel32' -PassThru

echo "Forcing system to not go to sleep (disable screen saver)."
echo "Close the window to allow sleep again."
$result = $Kernel32::SetThreadExecutionState($ES_CONTINUOUS -bor $ES_DISPLAY_REQUIRED -bor $ES_SYSTEM_REQUIRED)

# Loop until script is forcibly stopped.
While ($true) {
  Start-Sleep (60 * 60 * 24)  # 24 hours.
}

In meinem Fall hat nur diese eine Zeile den Trick gemacht:

SendKeys.Send("{CAPSLOCK}{CAPSLOCK}");

Setzen Sie es einfach in das Ereignis Timer_Tick und setzen Sie das Timerintervall auf z. B. 60000ms.

Ich habe eine winzige Tray-Icon-Anwendung CoffeeBean erstellt, die eine viel bessere und zuverlässigere Methode verwendet, um die Aktivität des Benutzers mithilfe der WinAPI-Funktion SetThreadExecutionState zu simulieren, die fast genau für diese Art von Anwendungsfall entwickelt wurde (z. B. ist es die Funktion, die von Videoplayern verwendet wird, um Ihren Bildschirm beim Ansehen eines Films eingeschaltet zu halten). Wenn Sie mit Autohotkey vertraut sind, können Sie alternativ dieses Autohotkey-Skript verwenden.

Der richtige Weg, um damit umzugehen, ist:

• gehen Sie in die Registrierung, in der die Richtlinie
• setzen Sie den Wert auf das, was Sie wollen
• und ändern Sie die Registrierungsschlüsselberechtigungen
• nur Verweigern Sie Schreibzugriff auf alle außer sich selbst

Sie sollten die "Bildschirmsperre"/"Schlafmodus" in der Systemsteuerung > Energieoptionen > Planeinstellungen ändern deaktivieren. Sie in klicken Sie auf die Dropdown-Liste für "Setzen Sie den Computer in den Ruhezustand" und wählen Sie "nie".