Um timer que bloqueia automaticamente a tela para tirar uma folga do computador?

61

Estou procurando um programa gráfico ou de linha de comando que forneça o seguinte fluxo de trabalho:

  1. Inicie uma sessão de 25 minutos
  2. Após a tela de 25min é automaticamente bloqueado por 5min (ou talvez apenas virou preto?)
  3. Agora sou ajudado a fazer uma pausa porque não posso fazer nada na frente do computador, a não ser olhar para uma tela preta ou bloqueada:)
  4. Após 5 minutos, a tela retorna automaticamente e eu posso continuar o trabalho

Existe um programa que faz exatamente isso?

    
por orschiro 11.11.2015 / 10:32

6 respostas

81

Uma aplicação completa provavelmente seria um pouco exagerada; um pequeno script de fundo está fazendo o trabalho.

O script abaixo irá, em um loop, fazer exatamente como você menciona: ele mantém a tela "normal" por um tempo arbitrário (em minutos, você pode usar floats para acertar os minutos parcialmente) e escurece a tela (s ) ou vira de cabeça para baixo, à sua escolha :), para o "breaktime".

ou:

Oscript

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

Como usar

  1. Copie o script em um arquivo vazio, salve-o como takeabreak.py
  2. À sua escolha, descomente a linha 15 ou 17 (você pode pular esta etapa se quiser apenas escurecer a tela), conforme indicado no script.
  3. Teste- execute o script a partir de um terminal pelo comando:

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

    por exemplo:

    python3 /path/to/takeabreak.py 25 5
    

    para fazer uma pausa de 5 minutos depois de trabalhar a cada 25 minutos

  4. Se ele fizer o que você deseja, adicione-o aos aplicativos de inicialização: Dash > Aplicativos de inicialização > Adicione o comando:

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



EDITAR

Claro, você pode "vestir" o roteiro com qualquer coisa que possa imaginar. A primeira coisa que vem à minha mente é uma pequena mensagem, notificando que a ruptura está próxima ...

Ocódigo

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

Elementos básicos da GUI para Unity

Como discutido nos comentários, abaixo de uma versão (configuração) com uma funcionalidade básica da GUI, para alternar o script e alterar as configurações de tempo de atividade / tempo de interrupção. Se você seguir as instruções, a configuração é bastante simples:)

Ingredientes:

  1. Doisscripts(maisabaixo):

    • takeabrake_run
      qualéoscriptreal,substituindoo(s)script(s)acima,

    e

    • takeabreak_gui
      queé,comoesperado,oscriptparagerenciarasconfigurações(detempo)eparamanipularoscript.
  2. umarquivo.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 um ícone:

    (cliquecomobotãodireitodomouseem>salveaimagemcomotakeabreak.png)

Comoconfigurar

  1. Crie,seaindanãoexistir,odiretório~/bin
  2. Façalogout/inouexecutesource~/.profilepara"ativar" a presença de ~/bin em $PATH
  3. Copie os dois scripts abaixo em dois arquivos vazios, nomeie-os (exatamente)

    takeabreak_gui
    

    e

    takeabreak_run
    

    (sem extensões!) e salve-as em ~/bin

  4. Torne os dois scripts executáveis (!)
  5. Copie o ícone ( right-click > save image as ) para o seu computador. Nomeie-o (exatamente) como takeabreak.png
  6. Copie o arquivo .desktop em um arquivo vazio. Edite a linha:

    Icon=/path/to/takeabreak.png
    

    e substitua o caminho para o ícone pelo caminho real.

É isso aí!

Os 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
    

Editar configurações de hora

A "GUI" básica deve funcionar sem muita explicação. Para editar as configurações de horário, adicione o lançador ao Iniciador Unity (arraste o arquivo .desktop pelo Iniciador Unity ou bloqueie "Fazer um intervalo" ao Iniciador), clique com o botão direito no lançador e escolha "Alterar configurações de horário":

Posteriormente,insirao"uptime" (minutos) e "breaktime" (minutos), separados por um espaço. O script tem precauções internas para entrada incorreta:)

Se as configurações de horário forem alteradas enquanto o script é executado, ele será reiniciado automaticamente com as configurações alteradas:

FINALMENTE

Porenquanto,provavelmenteaúltimaedição:oprojetoestáagorano launchpad - com muito de alterações, mais opções, etc. etc.

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

Sinta-se à vontade para enviar bugs, etc. aqui , ou comentar aqui . Obrigado a orschiro pela boa pergunta e Rinzwind pelo encorajamento!

segundos restantes (usando a opção countdown)

    
por Jacob Vlijm 11.11.2015 / 11:24
22

Você também pode querer considerar Workrave , embora não esteja mais em desenvolvimento. Eu achei fácil de usar e altamente personalizável. Ele também tem algumas boas estatísticas sobre como você usa o computador e quantas pausas você toma. Por último, acredito que também pode sincronizar-se entre muitos computadores, o que é útil se, por exemplo, você trabalha tanto no laptop quanto no computador de uma escola.

EDIT:Temmuitosoutrosrecursosqueeunãomencionei,comosugeriralgunsexercíciosparavocêfazerenquantoatelaestábloqueada.Eissopodelevaremcontaapenasotempoquevocêestáusandoocomputador,porissonãovaitefazerumapausaquandovocêvoltardobanheiro:)

EDIT2:

Certifique-sedeverificaromodo"Leitura"!

O recurso acima de contar apenas o tempo em que você está usando ativamente o computador pode ser visto como um bug se você não estiver fazendo muito (sem mouse, sem eventos de teclado) porque apenas solicitar sua pausa quando você acumular 1h de uso (ou quanto tempo você configurou). Nessas situações, a ativação do modo "Leitura" fará com que seja solicitado no momento exato, independentemente do uso.

    
por Ciprian Tomoiagă 11.11.2015 / 13:17
12

Forma bruta, minimalista e de linha de comando:

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

Isso também pode ser transformado em um atalho na área de trabalho ou ser ativado em .bashrc

Por que 1500 e 300? porque isso é segundos, 1500 segundos / 60 segundos por minuto = 25 minutos.

Abaixo está um script para um temporizador que permite definir a sessão variável e tempo de pausa, bem como métodos de sinalização da quebra.

Lembre-se de que qualquer script no Linux deve ser salvo como um arquivo e ter permissões executáveis definidas com chmod +x /path/to/script.sh . Uma vez feito isso, você pode vincular o script a um atalho como mostrado em Como vincular arquivos .sh à combinação de teclado? ou crie um atalho na área de trabalho como mostrado em Como posso criar lançadores na minha área de trabalho?

Ao iniciar o script, você verá um menu como este:

#!/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; # $1 is provided from chooseBreakMethod function ##################################################### function screenSaver { gnome-screensaver-command -l; sleep $1 ; 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 # $1 provided in chooseBreakMethod function ################################################## function dialogBreak { gnome-terminal --full-screen -e "bash -c 'sleep $1 | 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 # $1 is provided from chooseBreakMethod function ################################################################ function dimScreen { xrandr | awk '$2 == "connected" {print $1}' | xargs -I % xrandr --output % --brightness 0.5 notify-send 'Take a Break' sleep $1 xrandr | awk '$2 == "connected" {print $1}' | 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 { # $1 is method passed from ${SETS[3]} # $2 is break time passed from ${SETS[2]} case $1 in 1) dimScreen $2 ;; 2) dialogBreak $2 ; sleep $2 ;; 3) screenSaver $2 ;; esac } function minutesToSeconds { echo $(($1*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 ###########     
por Sergiy Kolodyazhnyy 16.11.2015 / 11:16
8

Aqui está outra ferramenta chamada Safe Eyes para o mesmo propósito.

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

Funcionalidades:

  • Pausascurtascomexercíciosparaosolhos
  • Pausaslongasparamudaraposiçãofísicaeaquecer
  • Pausaestritaparaqueméviciadoemcomputador
  • Nãoperturbeaotrabalharcomaplicativosdetelainteira(ex.:assistirafilmes)
  • Desativarotecladoduranteapausa
  • Notificaçõesantesdecadaintervalo
  • Suportaváriosmonitores
  • Pausaautomaticamenteseosistemaestiverocioso
  • Alertaaudívelopcionalnofinaldaspausas
  • Suporteemváriosidiomas

Paramaisdetalhes: link

    
por Gobinath 23.10.2016 / 14:52
6

Eu usei xwrits por muitos anos para esse propósito.

sudo apt-get install xwrits

O padrão é uma pausa de 5 minutos a cada 55 minutos, mas, de acordo com a página de manual , esses horários são personalizáveis através das opções de linha de comando breaktime e typetime , respectivamente. Você também pode controlar se ele bloqueia a tela usando a opção +lock . Então, para configurá-lo para um intervalo de 5 minutos a cada 25 minutos bloqueando você, você deve executá-lo assim

xwrits typetime=25 breaktime=5 +lock &
    
por Michael Mandel 16.11.2015 / 21:48
0

drwright era o componente de quebra de digitação que costumava fazer parte do gnome: link

e há um ppa disponível (embora eu não tenha usado pessoalmente pós-12.04): link

    
por andrew bezella 16.11.2015 / 23:09