Un timer che blocca automaticamente lo schermo per fare una pausa dal computer?

61

Sto cercando un programma grafico o a riga di comando che mi fornisca il seguente flusso di lavoro:

  1. Avvia una sessione di 25 minuti
  2. Dopo 25 minuti lo schermo viene automaticamente bloccato per 5 minuti (o forse è appena diventato nero?)
  3. Ora sono aiutato a fare una pausa perché non posso fare nulla davanti al computer se non guardando uno schermo nero o bloccato:)
  4. Dopo 5 minuti, lo schermo ritorna automaticamente e posso continuare a lavorare

Esiste un programma che fa esattamente questo?

    
posta orschiro 11.11.2015 - 10:32

6 risposte

81

Una applicazione completa sarebbe probabilmente una sorta di eccessivo; un piccolo script in background sta facendo il lavoro.

Lo script che segue, in un ciclo, fa esattamente ciò che menziona: mantiene lo schermo "normale" per un tempo arbitrario (in minuti, puoi usare i float per impostare i minuti parzialmente) e i neri fuori dallo schermo (s ) o lo capovolge, a tua scelta :), per il "tempo di interruzione".

o:

Lo 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()

Come usare

  1. Copia lo script in un file vuoto, salvalo come takeabreak.py
  2. A tua scelta, rimuovi il commento dalla riga 15 o 17 (puoi saltare questo passaggio se desideri che oscuri lo schermo), come indicato nello script.
  3. Test - esegui lo script da un terminale con il comando:

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

    ad esempio:

    python3 /path/to/takeabreak.py 25 5
    

    per fare una pausa di 5 minuti dopo aver lavorato ogni 25 minuti

  4. Se fa quello che vuoi, aggiungilo alle applicazioni di avvio: Dash & gt; Applicazioni di avvio & gt; Aggiungi il comando:

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

Modifica

Naturalmente, puoi "vestire" la sceneggiatura con qualsiasi cosa tu possa immaginare. La prima cosa che mi viene in mente è un piccolo messaggio, che ti informa che la pausa è vicina ...

Il codice

#!/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()

MODIFICA 2

Elementi di base della GUI per Unity

Come discusso nei commenti, sotto una versione (impostata) con una funzionalità GUI di base, per attivare lo script e modificare le impostazioni di uptime / breaktime. Se segui le istruzioni, l'installazione è abbastanza semplice:)

Ingredienti:

  1. Due script (più sotto):

    • takeabrake_run
      qual è lo script vero e proprio, sostituendo gli script sopra indicati,

    e

    • takeabreak_gui
      che è, come previsto, lo script per gestire le impostazioni (temporali) e toglle lo script.
  2. un file .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. e un'icona:


    (tasto destro & gt; salva immagine come takeabreak.png)

Come impostare

  1. Crea, se non esiste ancora, la directory ~/bin
  2. Esci / esci o esegui source ~/.profile per "attivare" la presenza di ~/bin in $PATH
  3. Copia entrambi gli script di seguito in due file vuoti, nominali (esattamente)

    takeabreak_gui
    

    e

    takeabreak_run
    

    (nessuna estensione!) e salvali in ~/bin

  4. Crea entrambi gli script eseguibili (!)
  5. Copia l'icona ( right-click > save image as ) sul tuo computer. Chiamalo (esattamente) come takeabreak.png
  6. Copia il file .desktop in un file vuoto. Modifica la riga:

    Icon=/path/to/takeabreak.png
    

    e sostituisci il percorso dell'icona con il percorso reale.

Questo è tutto!

Gli script:

  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
    

Modifica delle impostazioni del tempo

La "GUI" di base dovrebbe funzionare senza molte spiegazioni. Per modificare le impostazioni dell'ora, aggiungi l'utilità di avvio a Unity Launcher (trascina il file .desktop su Unity Launcher o blocca "Fai una pausa" all'avvio), fai clic con il pulsante destro del mouse sull'utilità di avvio e scegli "Modifica impostazioni ora":

Successivamente inserisci "tempo di attività" (minuti) e "tempo di interruzione" (minuti), separati da uno spazio. Lo script ha precauzioni incorporate per l'input non corretto:)

Se le impostazioni dell'ora vengono modificate mentre lo script è in esecuzione, si riavvia automaticamente con le impostazioni modificate:

FINALMENTE

Per ora probabilmente l'ultima modifica: il progetto è ora su launchpad -con molto di modifiche, più opzioni ecc. ecc.

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

Sentiti libero di presentare bug qui , o commentare here . Grazie a orschiro per la bella domanda, e Rinzwind per l'incoraggiamento!

durata residua - secondi (utilizzando l'opzione conto alla rovescia)

    
risposta data Jacob Vlijm 11.11.2015 - 11:24
22

Puoi anche prendere in considerazione Workrave , sebbene non sia più in fase di sviluppo. L'ho trovato facile da usare e altamente personalizzabile. Ha anche alcune statistiche utili su come si usa il computer e quante pause si prendono. Infine, credo che possa anche sincronizzarsi tra più computer, il che è utile se, ad esempio, lavori sia sul laptop che su un computer scolastico.

EDIT: Ha molte altre caratteristiche che non ho menzionato, come suggerire alcuni esercizi da fare mentre lo schermo è bloccato. E può prendere in considerazione solo il tempo in cui usi il computer, quindi non ti chiederà una pausa quando torni dal bagno:)

EDIT 2:

Assicurati di controllare la modalità "Lettura"!

La precedente funzione di contare solo il tempo in cui stai usando attivamente il computer può essere vista come un bug se non stai facendo molto (nessun mouse, nessun evento di tastiera) perché fai solo una pausa quando accumuli 1 ora di utilizzo (o quanto tempo hai impostato). In queste situazioni, l'attivazione della modalità "Lettura" lo renderà tempestivo all'orario esatto, indipendentemente dall'utilizzo.

    
risposta data Ciprian Tomoiagă 11.11.2015 - 13:17
12

Modalità di riga di comando grezza, minimalista:

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

Può anche essere trasformato in un collegamento sul desktop o trasformato in funzione in .bashrc

Perché 1500 e 300? perché è secondi, 1500 secondi / 60 secondi al minuto = 25 minuti.

Di seguito è riportato uno script per un timer che consente di impostare la sessione variabile e il tempo di interruzione, nonché i metodi di segnalazione dell'interruzione.

Ricorda che qualsiasi script su linux deve essere salvato come file e avere autorizzazioni eseguibili impostate con chmod +x /path/to/script.sh . Una volta fatto, puoi associare lo script a un collegamento come mostrato in Come si associano i file .sh alla combinazione di tasti? oppure crea una scorciatoia sul desktop come mostrato in Come posso creare i launcher sul mio desktop?

Quando avvii lo script dovresti vedere un menu come questo:

#!/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 ###########
    
risposta data Sergiy Kolodyazhnyy 16.11.2015 - 11:16
8

Ecco un altro strumento chiamato Safe Eyes per lo stesso scopo.

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

Caratteristiche:

  • Brevi pause con esercizi per gli occhi
  • Lunghe pause per cambiare posizione fisica e scaldarsi
  • Interruzione rigorosa per coloro che sono dipendenti dal computer
  • Non disturbare quando si lavora con applicazioni a schermo intero (ad esempio: visione di film)
  • Disattiva la tastiera durante l'interruzione
  • Notifiche prima di ogni interruzione
  • Supporta più schermi
  • Metti in pausa automaticamente se il sistema è inattivo
  • Avviso acustico opzionale alla fine delle interruzioni
  • Supporto multilingue

Per ulteriori dettagli: link

    
risposta data Gobinath 23.10.2016 - 14:52
6

Ho usato xwrits per molti anni per questo scopo.

sudo apt-get install xwrits

Il valore predefinito è una pausa di 5 minuti ogni 55 minuti, ma secondo la pagina man questi orari sono personalizzabili tramite le opzioni della riga di comando breaktime e typetime , rispettivamente. Puoi anche controllare se blocca lo schermo usando l'opzione +lock . Quindi, impostandolo per una pausa di 5 minuti ogni 25 minuti che ti blocca, dovresti eseguirlo in questo modo

xwrits typetime=25 breaktime=5 +lock &
    
risposta data Michael Mandel 16.11.2015 - 21:48
0

drwright era il componente di interruzione tipizzazione che era parte di gnome: link

e c'è un ppa disponibile (anche se non ho usato personalmente il post-12.04): link

    
risposta data andrew bezella 16.11.2015 - 23:09

Leggi altre domande sui tag