Une minuterie qui verrouille automatiquement l'écran pour prendre une pause de l'ordinateur?

61

Je recherche un programme graphique ou en ligne de commande qui me fournisse le workflow suivant:

  1. Démarrer une session de 25 minutes
  2. Après 25 minutes, l’écran est automatiquement verrouillé pendant 5 minutes (ou peut-être juste devenu noir?)
  3. Maintenant, je suis aidé à faire une pause car je ne peux rien faire d'autre que regarder un écran noir ou verrouillé devant l'ordinateur:)
  4. Après 5min, l’écran retourne automatiquement et je peux continuer à travailler

Existe-t-il un programme qui fait exactement cela?

    
posée orschiro 11.11.2015 - 10:32
la source

6 réponses

81

Une application complète serait probablement un peu exagérée; un script de fond minuscule fait le travail.

Le script ci-dessous va, comme une boucle, faire exactement comme vous le mentionnez: il garde l'écran "normal" pour un temps arbitraire (en minutes, vous pouvez utiliser des flottants pour définir les minutes) et noircir l'écran (s) ) ou le retourne à votre choix :), pour le "breaktime".

ou:

Le script

#!/usr/bin/env python3
import subprocess
import sys
import time

awaketime = int(float(sys.argv[1])*60)
sleeptime = int(float(sys.argv[2])*60)

def take_a_break():
    get = subprocess.check_output(["xrandr"]).decode("utf-8").split()
    screens = [get[i-1] for i in range(len(get)) if get[i] == "connected"]
    for scr in screens:
        # uncomment either one of the commands below [1]
        # darken the screen, or...
        subprocess.call(["xrandr", "--output", scr, "--brightness", "0"])
        # turn it upside down :)
        # subprocess.call(["xrandr", "--output", scr, "--rotate", "inverted"])
    time.sleep(sleeptime)
    for scr in screens:
        # back to "normal"
        subprocess.call(["xrandr", "--output", scr, "--brightness", "1"])
        subprocess.call(["xrandr", "--output", scr, "--rotate", "normal"])


while True:
    time.sleep(awaketime)
    take_a_break()

Comment utiliser

  1. Copiez le script dans un fichier vide, enregistrez-le sous le nom takeabreak.py
  2. À votre choix, supprimez le commentaire de la ligne 15 ou 17 (vous pouvez ignorer cette étape si vous souhaitez l’assombrir), comme indiqué dans le script.
  3. Testez le script depuis un terminal par la commande:

    python3 /path/to/takeabreak.py <uptime> <breaktime>
    

    par exemple:

    python3 /path/to/takeabreak.py 25 5
    

    prendre une pause de 5 minutes après avoir travaillé toutes les 25 minutes

  4. S'il fait ce que vous voulez, ajoutez-le aux applications de démarrage: Dash & gt; Applications de démarrage & gt; Ajoutez la commande:

    /bin/bash -c "sleep 15 && python3 /path/to/takeabreak.py 25 5"
    



EDIT

Bien sûr, vous pouvez "habiller" le script avec tout ce que vous pouvez imaginer. La première chose qui me vient à l’esprit est un petit message, vous avertissant que la pause est proche…

Le code

#!/usr/bin/env python3
import subprocess
import sys
import time

awaketime = int(float(sys.argv[1])*60)
sleeptime = int(float(sys.argv[2])*60)

message = "Break in 15 seconds"

def take_a_break():
    get = subprocess.check_output(["xrandr"]).decode("utf-8").split()
    screens = [get[i-1] for i in range(len(get)) if get[i] == "connected"]
    for scr in screens:
        # uncomment either one of the commands below [1]
        # darken the screen, or...
        subprocess.call(["xrandr", "--output", scr, "--brightness", "0"])
        # turn it upside down :)
        # subprocess.call(["xrandr", "--output", scr, "--rotate", "inverted"])
    time.sleep(sleeptime)
    for scr in screens:
        # back to "normal"
        subprocess.call(["xrandr", "--output", scr, "--brightness", "1"])
        subprocess.call(["xrandr", "--output", scr, "--rotate", "normal"])

while True:
    time.sleep(awaketime-15)
    subprocess.Popen(["notify-send", message])
    time.sleep(15)
    take_a_break()

EDIT 2

Éléments graphiques de base pour Unity

Comme indiqué dans les commentaires, sous une version (configurée) avec une fonctionnalité graphique de base, pour basculer le script et modifier les paramètres de disponibilité / pause. Si vous suivez les instructions, la configuration est assez simple:)

Ingrédients:

  1. Deux scripts (plus bas):

    • takeabrake_run
      qui est le script actuel, remplaçant le ou les scripts ci-dessus,

    et

    • takeabreak_gui
      qui est, comme prévu, le script permettant de gérer les paramètres (heure) et d'ajuster le script.
  2. un fichier .desktop :

    [Desktop Entry]
    Type=Application
    Name=Take a Break
    Exec=takeabreak_gui toggle
    Icon=/path/to/takeabreak.png
    
    Actions=Toggle script;Change time settings;
    
    [Desktop Action Change time settings]
    Name=Change time settings
    Exec=takeabreak_gui timeset
    OnlyShowIn=Unity;
    
    [Desktop Action Toggle script]
    Name=Toggle script
    Exec=takeabreak_gui toggle
    OnlyShowIn=Unity;
    
  3. et une icône:


    (clic droit & gt; enregistrer l'image sous takeabreak.png)

Comment configurer

  1. Créez, s’il n’existe pas encore, le répertoire ~/bin
  2. Déconnectez-vous ou entrez source ~/.profile pour "activer" la présence de ~/bin in $PATH
  3. Copiez les deux scripts ci-dessous dans deux fichiers vides, nommez-les (exactement)

    takeabreak_gui
    

    et

    takeabreak_run
    

    (pas d’extensions!) et les enregistrer dans ~/bin

  4. Rendez les deux scripts exécutables (!)
  5. Copiez l'icône ( right-click > save image as ) sur votre ordinateur. Nommez-le (exactement) comme takeabreak.png
  6. Copiez le fichier .desktop dans un fichier vide. Modifier la ligne:

    Icon=/path/to/takeabreak.png
    

    et remplacez le chemin d'accès à l'icône par le chemin réel.

C'est ça!

Les scripts:

  1. takeabreak_run

    #!/usr/bin/env python3
    import subprocess
    import sys
    import time
    
    awaketime = int(float(sys.argv[1])*60)
    sleeptime = int(float(sys.argv[2])*60)
    
    message = "Break in 15 seconds"
    
    def take_a_break():
        get = subprocess.check_output(["xrandr"]).decode("utf-8").split()
        screens = [get[i-1] for i in range(len(get)) if get[i] == "connected"]
        for scr in screens:
            # uncomment either one of the commands below [1]
            # darken the screen, or...
            subprocess.call(["xrandr", "--output", scr, "--brightness", "0"])
            # turn it upside down :)
            # subprocess.call(["xrandr", "--output", scr, "--rotate", "inverted"]); time.sleep(0.2)
        time.sleep(sleeptime)
        for scr in screens:
            # back to "normal"
            subprocess.call(["xrandr", "--output", scr, "--brightness", "1"]); time.sleep(0.2)
            subprocess.call(["xrandr", "--output", scr, "--rotate", "normal"]); time.sleep(0.2)
    
    while True:
        time.sleep(awaketime-15)
        subprocess.Popen(["notify-send", message])
        time.sleep(15)
        take_a_break()
    
  2. takeabreak_gui

    #!/usr/bin/env python3
    import os
    import subprocess
    import sys
    
    # define the settings file's location
    setting = os.environ["HOME"]+"/"+".time_setting"
    # default values (if no settinghs were made)
    default_up = "25"
    default_break = "5"
    
    arg = sys.argv[1]
    
    def check_running():
        # function to check if the script runs
        try:
            return subprocess.check_output(["pgrep", "-f", "takeabreak_run"]).decode("utf-8").strip()
        except subprocess.CalledProcessError:
            return False
    
    def start(uptime, breaktime):
        # function to start the script with arguments
        print(uptime, breaktime)
        subprocess.Popen(["takeabreak_run", uptime, breaktime])
    
    def kill(pid):
        # function to stop the script
        subprocess.Popen(["kill", pid])
    
    def message(msg):
        # function to send a notification
        subprocess.Popen(["notify-send", msg])
    
    if arg == "toggle":
        # the section below handles toggling the script
        pid = check_running()
        if pid != False:
            kill(pid)
            message("Take a break stopped...")
        else:
            try:
                # if settings file exist: message, displaying set time
                time_set = open(setting).read().strip().split()
                uptime = time_set[0]; breaktime = time_set[1]
            except FileNotFoundError:
                # if no settings were made: use defaults
                uptime = default_up; breaktime = default_break
            message("Take a break started ("+uptime+"/"+breaktime+")")
            start(uptime, breaktime)
    
    if arg == "timeset":
        # the section below handle creating the settings file and/or setting the time
        command = 'zenity --entry --title="Edit time settings" --text="Enter uptime & breaktime:" --entry-text "'+\
                  default_up+' '+default_break+'"'
        try:
            t_set = subprocess.check_output(["/bin/bash", "-c", command]).decode("utf-8").split()
            try:
                if len([int(n) for n in t_set]) != 2:
                    msg = 'zenity --warning --text="Please enter both (and only) up- and breaktime."'
                else:
                    msg = 'zenity --info --title="New setings" --text="Timesettings succsfully changed."'
                    open(setting, "wt").write((" ").join(t_set))
                    pid = check_running()
                    # if script runs, restart with new values
                    if pid != False:
                        kill(pid)
                        start(t_set[0], t_set[1])
                        message("Take a break restarted "+("/").join(t_set))
            except ValueError:
                msg = 'zenity --warning --text="Please only enter integers."'
            subprocess.Popen(["/bin/bash", "-c", msg])
        except subprocess.CalledProcessError:
            pass
    

Modification des paramètres d’heure

Le "GUI" de base devrait fonctionner sans trop d'explications. Pour modifier les paramètres de l'heure, ajoutez le lanceur au lanceur Unity (faites glisser le fichier .desktop sur le lanceur Unity ou verrouillez le lanceur), cliquez avec le bouton droit sur le lanceur et choisissez "Modifier les paramètres de l'heure": / p>

Entrez ensuite le "temps de disponibilité" (minutes) et "pause" (minutes), séparés par un espace. Le script a des précautions intégrées pour une saisie incorrecte:)

Si les paramètres d'heure sont modifiés pendant l'exécution du script, il redémarre automatiquement avec les paramètres modifiés:

FINALEMENT

Pour le moment probablement la dernière édition: le projet est maintenant sur tableau de bord - avec beaucoup des changements, plus d'options, etc. etc.

sudo add-apt-repository ppa:vlijm/takeabreak
sudo apt-get update
sudo apt-get install takeabreak

N'hésitez pas à déposer des bogues, etc. ici , ou commentez ici . Merci à orschiro pour la belle question et Rinzwind pour les encouragements!

secondes de pause restantes (en utilisant l'option de compte à rebours)

    
réponse donnée Jacob Vlijm 11.11.2015 - 11:24
la source
22

Vous pouvez également envisager Workrave , bien qu’il ne soit plus en développement. Je l'ai trouvé facile à utiliser et hautement personnalisable. Il a également quelques statistiques intéressantes sur la façon dont vous utilisez l'ordinateur et combien de pauses vous prenez. Enfin, je pense qu’elle peut également se synchroniser entre plusieurs ordinateurs, ce qui est utile si, par exemple, vous travaillez à la fois sur un ordinateur portable et sur un ordinateur d’école.

EDIT: Il a beaucoup d’autres fonctionnalités que je n’ai pas mentionnées, comme de suggérer quelques exercices à faire pendant que l’écran est bloqué. Et il ne peut prendre en compte que le temps que vous utilisez l'ordinateur, donc il ne vous incitera pas à faire une pause lorsque vous reviendrez des toilettes:)

EDIT 2:

Assurez-vous de vérifier le mode "Lecture"!

La fonctionnalité ci-dessus consistant à ne compter que le temps pendant lequel vous utilisez activement l’ordinateur peut être considérée comme un bogue si vous ne faites pas beaucoup (pas de souris, pas d’événements de clavier) ne déclenchez votre pause que lorsque vous cumulez 1 heure d'utilisation (ou combien de temps vous avez configuré). Dans ces situations, l'activation du mode "Lecture" le rendra prompt à l'heure exacte, quelle que soit son utilisation.

    
réponse donnée Ciprian Tomoiagă 11.11.2015 - 13:17
la source
12

Brut, minimaliste, par ligne de commande:

sleep 1500; gnome-screensaver-command -l; sleep 300; killall gnome-screensaver

Cela peut également être transformé en raccourci sur le bureau ou transformé en fonction dans .bashrc

Pourquoi 1500 et 300? parce que c'est des secondes, 1500 secondes / 60 secondes par minute = 25 minutes.

Vous trouverez ci-dessous un script pour une minuterie qui permet de définir des sessions de variables et des temps de pause, ainsi que des méthodes pour signaler la rupture.

N'oubliez pas que tout script sur Linux doit être enregistré en tant que fichier et avoir des autorisations exécutables définies avec chmod +x /path/to/script.sh . Une fois cela fait, vous pouvez lier le script à un raccourci comme indiqué dans Comment associer des fichiers .sh à une combinaison de clavier? ou créez un raccourci sur le bureau, comme indiqué dans Comment créer des lanceurs sur mon bureau?

Lorsque vous lancez le script, vous devriez voir un menu comme celui-ci:

#!/bin/bash

# Author: Serg Kolo
# Date : Nov 17th, 2015
# Purpose: pomodoro timer script,
# with bunch of options
# Written for: https://askubuntu.com/q/696620/295286

#####################################################
# screenSaver function
# this one uses gnome-screensaver-command for locking
# and killall for unlocking the screen;
#  is provided from chooseBreakMethod function
#####################################################

function screenSaver
{
  gnome-screensaver-command -l; sleep  ; killall gnome-screensaver 
}


##############################################
# dialogBreak function
# this serves as "screensaver". The screen is never 
# actually locked but rather we open terminal window 
# with a simple command line dialog
# in full sccrean mode
#  provided in chooseBreakMethod function
##################################################
function dialogBreak
{
 gnome-terminal --full-screen  -e  "bash -c 'sleep  | dialog --progressbox \"TAKE A BREAK\" 100 100 ' "
}

#################################################################
# dimScreen function 
# dims the screen using xrandr; the --brightness 
# can be configured
# for full or partial dimming using decimal values
# from 1 to 0
#  is provided from chooseBreakMethod function
################################################################

function dimScreen
{
  xrandr  | awk ' == "connected" {print }' | xargs -I % xrandr --output % --brightness 0.5
  notify-send 'Take a Break'
  sleep 
  xrandr  | awk ' == "connected" {print }' | xargs -I % xrandr --output % --brightness 1
}

##############################
# getSettings function
# This is where the user enters 
# the settings they want
# All the values must be integers
#############################
function getSettings
{
  FORM=$(zenity --forms \ --title="Sergiy's Tomato Script" --text="Choose this session options" \
   --add-entry="Number of Sessions (how many loops)" \
   --add-entry="Session time (minutes)" \
   --add-entry="Break time (minutes)" \
   --add-entry="Dim,dialog,or screensaver? (1,2,3)" \
   --separator=" " )  

  [ $? -eq 0 ] || exit 1

   echo $FORM
}

################################
# chooseBreakMethod function
# A helper function that calls appropriate
# break method, based on the value we got
# from getSettings function
# Because dialogBreak calls gnome-terminal
# this function exits, so it doesn't wait
# Therefore we need to add additional sleep
# command
###############################

function chooseBreakMethod
{

 #  is method passed from  ${SETS[3]}
 #  is break time passed from ${SETS[2]}
  case  in
    1) dimScreen  ;;
        2) dialogBreak  ; sleep  ;;
    3) screenSaver  ;;
  esac

}


function minutesToSeconds
{
  echo $((*60))
}

#################
# MAIN
#################

# get user settings and store them into array
# Item 0 : num sessions
# Item 1 : session duration
# Item 2 : break duration
# Item 3 : break method - lockscreen, dialog, or just
# turn off the screen 
# SETS == settings
SETS=( $(getSettings) )

COUNTER=${SETS[0]}

#######################################
# This is where most of the job is done
# we loop according to number of session
# specified in the  getSettings function
#########################################

notify-send 'Session started'
while [ $COUNTER -ne 0  ]; do

  sleep $( minutesToSeconds ${SETS[1]} ) # session timer
  chooseBreakMethod ${SETS[3]} $( minutesToSeconds ${SETS[2]} )
  COUNTER=$(($COUNTER-1))
done

notify-send "tomatoScript is done"
####### END OF SCRIT ###########
    
réponse donnée Sergiy Kolodyazhnyy 16.11.2015 - 11:16
la source
8

Voici un autre outil appelé Safe Eyes pour le même objectif.

sudo add-apt-repository ppa:slgobinath/safeeyes
sudo apt-get update
sudo apt-get install safeeyes

Fonctionnalités:

  • Pauses courtes avec des exercices oculaires
  • De longues pauses pour changer de position physique et se réchauffer
  • Pause stricte pour ceux qui sont dépendants de l'ordinateur
  • Ne pas déranger lorsque vous travaillez avec des applications en plein écran (par exemple: Regarder des films)
  • Désactiver le clavier pendant les pauses
  • Notifications avant chaque pause
  • Prend en charge plusieurs affichages
  • Pause automatique si le système est inactif
  • Alerte sonore optionnelle à la fin des pauses
  • Support multilingue

Pour plus de détails: lien

    
réponse donnée Gobinath 23.10.2016 - 14:52
la source
6

J'ai utilisé xwrits pendant de nombreuses années à cette fin.

sudo apt-get install xwrits

La valeur par défaut est une pause de 5 minutes toutes les 55 minutes, mais selon la page de manuel , ces temps sont personnalisables. via les options de ligne de commande breaktime et typetime , respectivement. Vous pouvez également contrôler s'il verrouille l'écran à l'aide de l'option +lock . Donc, pour une pause de 5 minutes toutes les 25 minutes, vous devez vous en sortir comme ça

xwrits typetime=25 breaktime=5 +lock &
    
réponse donnée Michael Mandel 16.11.2015 - 21:48
la source
0

drwright était le composant de rupture de frappe qui faisait partie de gnome: lien

et il y a un ppa disponible (bien que je n'ai pas utilisé personnellement après le 12.04): lien

    
réponse donnée andrew bezella 16.11.2015 - 23:09
la source

Lire d'autres questions sur les étiquettes