Gibt es eine Möglichkeit, einen Countdown- oder Stoppuhr-Timer in einem Terminal anzuzeigen?

144

Wie kann ich einen Echtzeit-Countdown-Timer auf dem Linux-Terminal anzeigen? Gibt es eine bestehende App oder noch besser einen One Liner, um dies zu tun?

tir38
quelle

Antworten:

184

Ich bin mir nicht sicher, warum Sie das brauchen beep. Wenn Sie nur eine Stoppuhr wollen, können Sie dies tun:

while true; do echo -ne "`date`\r"; done

Das zeigt Ihnen die Sekunden in Echtzeit und Sie können es mit Ctrl+ stoppen C. Wenn Sie eine höhere Genauigkeit benötigen, können Sie diese verwenden, um Nanosekunden zu erhalten:

while true; do echo -ne "`date +%H:%M:%S:%N`\r"; done

Wenn Sie wirklich, wirklich "Stoppuhr-Format" wollen, bei dem alles bei 0 beginnt und wächst, können Sie Folgendes tun:

date1=`date +%s`; while true; do 
   echo -ne "$(date -u --date @$((`date +%s` - $date1)) +%H:%M:%S)\r";
done

Für einen Countdown-Timer (was nicht Ihre ursprüngliche Frage ist) können Sie dies tun (ändern Sie die Sekunden entsprechend):

seconds=20; date1=$((`date +%s` + $seconds)); 
while [ "$date1" -ge `date +%s` ]; do 
  echo -ne "$(date -u --date @$(($date1 - `date +%s` )) +%H:%M:%S)\r"; 
done

Sie können diese zu einfachen Befehlen kombinieren, indem Sie bash-Funktionen (oder die von Ihnen bevorzugte Shell) verwenden. Fügen Sie in bash die folgenden Zeilen zu Ihrer hinzu ~/.bashrc(dadurch sleep 0.1wartet das System zwischen jedem Durchlauf eine Zehntelsekunde, damit Sie Ihre CPU nicht spammen):

function countdown(){
   date1=$((`date +%s` + $1)); 
   while [ "$date1" -ge `date +%s` ]; do 
     echo -ne "$(date -u --date @$(($date1 - `date +%s`)) +%H:%M:%S)\r";
     sleep 0.1
   done
}
function stopwatch(){
  date1=`date +%s`; 
   while true; do 
    echo -ne "$(date -u --date @$((`date +%s` - $date1)) +%H:%M:%S)\r"; 
    sleep 0.1
   done
}

Sie können dann einen Countdown-Timer von einer Minute starten, indem Sie Folgendes ausführen:

countdown 60

Sie können zwei Stunden zählen mit:

countdown $((2*60*60))

oder einen ganzen Tag mit:

countdown $((24*60*60))

Und starten Sie die Stoppuhr mit:

stopwatch

Wenn Sie in der Lage sein müssen, mit Tagen sowie Stunden, Minuten und Sekunden umzugehen, können Sie Folgendes tun:

countdown(){
    date1=$((`date +%s` + $1));
    while [ "$date1" -ge `date +%s` ]; do 
    ## Is this more than 24h away?
    days=$(($(($(( $date1 - $(date +%s))) * 1 ))/86400))
    echo -ne "$days day(s) and $(date -u --date @$(($date1 - `date +%s`)) +%H:%M:%S)\r"; 
    sleep 0.1
    done
}
stopwatch(){
    date1=`date +%s`; 
    while true; do 
    days=$(( $(($(date +%s) - date1)) / 86400 ))
    echo -ne "$days day(s) and $(date -u --date @$((`date +%s` - $date1)) +%H:%M:%S)\r";
    sleep 0.1
    done
}

Beachten Sie, dass die stopwatchFunktion seit Tagen nicht mehr getestet wurde, da ich eigentlich nicht 24 Stunden darauf warten wollte. Es sollte funktionieren, aber bitte lassen Sie es mich wissen, wenn es nicht funktioniert.

terdon
quelle
9
Ich habe diese netten Funktionen zu meiner .zshrcRechten hinzugefügt, nachdem ich Ihre Antwort gelesen habe. Heute habe ich countdowndas erste Mal benutzt und eine ziemlich hohe CPU-Auslastung festgestellt. Ich fügte ein sleep 0.1(ich weiß nicht, ob eine Ruhezeit von einem Bruchteil einer Sekunde auf allen Systemen unterstützt wird) hinzu, das das viel verbesserte. Der Nachteil ist natürlich eine weniger genaue Anzeigegenauigkeit, aber ich kann mit einer Abweichung von max. 100ms.
mpy
@mpy danke, dass du das erwähnt hast. Ich erhalte ~ 3% CPU - Auslastung , wenn diese dabei bash, kann ich damit leben (obwohl es ist höher als ich erwartet hatte , und ich habe auch den Schlaf zu meinem eigenen .bashrc hinzugefügt).
Terdon
3
Habe gerade diese Antwort gefunden. Ich fand es praktisch, den Wagenrücklauf am Anfang der Echo-Anweisung in der Stoppuhr-Funktion zu platzieren, da das Beenden der Stoppuhr nicht die aktuelle Stoppuhr-Zeit überschrieb: echo -ne "\ r $ (Datum -u --date @ $ (( date +%s- $ date1)) +% H:% M:% S) ";
Mkingston
3
@chishaku: Unter OS X schien dies für mich zu funktionieren: echo -ne "$(date -ju -f %s $(($date1 - Datum +% s )) +%H:%M:%S)\r";
user1071847
1
Mit SOx - Paket würde ich einen schönen Klang fügen Sie am Ende des Countdowns zu spielen: play -q -n synth 2 pluck C5.
Pablo A
94

Mein Lieblingsweg ist:

Anfang:

time cat

Halt:

ctrl+c

Wie @wjandrea unten kommentiert, ist eine andere Version auszuführen:

time read

und drücken Sie Enter, um zu stoppen

alfasin
quelle
8
Ähnlich, aber Sie können die Eingabetaste drücken, um es zu stoppen:time read
wjandrea
10
time readschlägt in zsh fehl, time (read)funktioniert aber .
Sparhawk
Das Problem ist jedoch, dass Sie die Zeit nicht sehen können, ohne sie abzubrechen oder zu beenden. Wenn Sie es dann neu starten, beginnt der Timer von neuem.
Zelphir Kaltstahl
39

Ich suchte das Gleiche und schrieb am Ende etwas ausführlicheres in Python:

Dies gibt Ihnen einen einfachen Countdown von 10 Sekunden:

sudo pip install termdown
termdown 10

Quelle: https://github.com/trehn/termdown

trehn
quelle
1
@DoktoroReichard: Nun, das ist ein Downloadlink.
Harrymc
1
@ Suhaib: Es sollte und tut für mich. Bitte werfen Sie ein Problem auf GitHub mit mehr Informationen auf.
Trehn
1
Ich liebe es - das ist genau das Richtige für mich
Wayne Werner
1
Sehr schön, ich mag die ASCII
Guillermo
1
Das ist wirklich cool! 😄
Orschiro
13

Ich habe diesen benutzt:

countdown()
(
  IFS=:
  set -- $*
  secs=$(( ${1#0} * 3600 + ${2#0} * 60 + ${3#0} ))
  while [ $secs -gt 0 ]
  do
    sleep 1 &
    printf "\r%02d:%02d:%02d" $((secs/3600)) $(( (secs/60)%60)) $((secs%60))
    secs=$(( $secs - 1 ))
    wait
  done
  echo
)

Beispiel:

 countdown "00:07:55"

Hier ist eine Quelle .

Adobe
quelle
2
POSIX-konform - funktioniert unter OS X :)
djule5
13
sh-3.2# man leave

Stellen Sie einen Timer für 15 Minuten ein

sh-3.2# leave +0015
Alarm set for Thu Nov  3 14:19:31 CDT 2016. (pid 94317)
sh-3.2#

edit: Ich hatte eine Reihe von Links offen, und ich dachte, dies sei spezifisch für osx, tut mir leid. Lassen Sie meine Antwort offen, damit andere wissen, dass sie in den BSDs Urlaub haben.

efk
quelle
1
leave funktioniert auch unter Linux, aber zuerst müssen Sie das leave-Programm aus den Standard-Repositorys installieren.
Karl
6

Dies ist für eine Stoppuhr mit Hundertstelsekunden:

#!/usr/bin/awk -f
function z() {
  getline < "/proc/uptime"
  close("/proc/uptime")
  return $0
}
BEGIN {
  x = z()
  while (1) {
    y = z()
    printf "%02d:%05.2f\r", (y - x) / 60, (y - x) % 60
  }
}

Beispiel

Steven Penny
quelle
Schöne Nur-Linux-Lösung! Ich liebe den Mangel an externen Anrufen. Beachten Sie, dass mein Debian-System zwei Werte in / proc / uptime hat, wobei sich der zweite vermutlich auf meine vorherige Verfügbarkeit bezieht. Dieses Skript kann angepasst werden, um Abhilfe zu schaffen, indem Zeile 5 aufreturn $1
Adam Katz
4

Ich habe die sehr gute Antwort von terdon in eine Funktion zusammengefasst, die gleichzeitig die Zeit seit dem Start und die Zeit bis zum Ende anzeigt. Es gibt auch drei Varianten, so dass es einfacher ist aufzurufen (Sie müssen keine Bash-Berechnungen durchführen) und es ist auch abstrahiert. Anwendungsbeispiel :

{ ~ }  » time_minutes 15
Counting to 15 minutes
Start at 11:55:34     Will finish at 12:10:34
     Since start: 00:00:08     Till end:  00:14:51

Und so etwas wie Arbeitstimer:

{ ~ }  » time_hours 8
Counting to 8 hours
Start at 11:59:35   Will finish at 19:59:35
     Since start: 00:32:41     Till end:  07:27:19

Und wenn Sie eine ganz bestimmte Zeit brauchen:

{ ~ }  » time_flexible 3:23:00
Counting to 3:23:00 hours
Start at 12:35:11   Will finish at 15:58:11
     Since start: 00:00:14     Till end:  03:22:46

Hier ist der Code , der in Ihre .bashrc eingefügt werden soll

function time_func()
{
   date2=$((`date +%s` + $1));
   date1=`date +%s`;
   date_finish="$(date --date @$(($date2)) +%T )"

   echo "Start at `date +%T`   Will finish at $date_finish"

    while [ "$date2" -ne `date +%s` ]; do
     echo -ne "     Since start: $(date -u --date @$((`date +%s` - $date1)) +%H:%M:%S)     Till end:  $(date -u --date @$(($date2 - `date +%s`)) +%H:%M:%S)\r";
     sleep 1
    done

    printf "\nTimer finished!\n"
    play_sound ~/finished.wav
}

function time_seconds()
{
  echo "Counting to $1 seconds"
  time_func $1
}

function time_minutes()
{
  echo "Counting to $1 minutes"
  time_func $1*60
}

function time_hours()
{
  echo "Counting to $1 hours"
  time_func $1*60*60
}

function time_flexible()  # accepts flexible input hh:mm:ss
{
    echo "Counting to $1"
    secs=$(time2seconds $1)
    time_func $secs
}

function play_sound()  # adjust to your system
{
    cat $1 > /dev/dsp
}

function time2seconds() # changes hh:mm:ss to seconds, found on some other stack answer
{ 
    a=( ${1//:/ }) 
    echo $((${a[0]}*3600+${a[1]}*60+${a[2]})) 
}

Kombinieren Sie dies mit einem gewissen Art und Weise von Spielen Sound in Linux - Terminal ( Wiedergabe von MP3 oder WAV - Datei über Linux - Befehlszeile ) oder Cygwin ( cat /path/foo.wav > /dev/dsp funktioniert für mich in Babun / win7) und Sie haben einen einfachen flexible Timer mit Alarm !

Koshmaar
quelle
4

Ein anderer Ansatz

countdown=60 now=$(date +%s) watch -tpn1 echo '$((now-$(date +%s)+countdown))'

Für Mac:

countdown=60 now=$(date +%s) watch -tn1 echo '$((now-$(date +%s)+countdown))'
#no p option on mac for watch

Wenn man ein Signal haben möchte, wenn es Null erreicht, kann man es beispielsweise mit einem Befehl erstellen, der einen Exit-Status ungleich Null bei Null zurückgibt, und es mit watch -betwas anderem kombinieren , aber wenn man ein ausführlicheres Skript erstellen möchte, ist dies wahrscheinlich nicht der Weg zu gehen; Es handelt sich eher um eine "schnelle und schmutzige Einzeiler" -Lösung.


Ich mag das watchProgramm im Allgemeinen. Ich habe es zum ersten Mal gesehen, nachdem ich bereits unzählige while sleep 5; doLoops mit unterschiedlichen Effekten geschrieben hatte. watchwar nachweislich schöner.

Daniel Andersson
quelle
3

Am Ende habe ich mein eigenes Shell-Skript geschrieben: github gist

#!/bin/sh
# script to create timer in terminal
# Jason Atwood
# 2013/6/22

# start up
echo "starting timer script ..."
sleep 1 # seconds

# get input from user
read -p "Timer for how many minutes?" -e DURATION
DURATION=$(( $DURATION*60 )) # convert minutes to seconds

# get start time
START=$(date +%s)

# infinite loop
while [ -1 ]; do
clear # clear window

# do math
NOW=$(date +%s) # get time now in seconds
DIF=$(( $NOW-$START ))  # compute diff in seconds
ELAPSE=$(( $DURATION-$DIF ))    # compute elapsed time in seconds
MINS=$(( $ELAPSE/60 ))  # convert to minutes... (dumps remainder from division)
SECS=$(( $ELAPSE - ($MINS*60) )) # ... and seconds

# conditional
if [ $MINS == 0 ] && [ $SECS == 0 ] # if mins = 0 and secs = 0 (i.e. if time expired)
then # blink screen
for i in `seq 1 180`; # for i = 1:180 (i.e. 180 seconds)
do
clear # flash on
setterm -term linux -back red -fore white # use setterm to change background color
echo "00:00 " # extra tabs for visibiltiy

sleep 0.5

clear # flash off
setterm -term linux -default # clear setterm changes from above
echo "00:00" # (i.e. go back to white text on black background)
sleep 0.5
done # end for loop
break   # end script

else # else, time is not expired
echo "$MINS:$SECS"  # display time
sleep 1 # sleep 1 second
fi  # end if
done    # end while loop 
tir38
quelle
1
Nettes Skript, +1. Nur damit Sie wissen, dass dies ein Countdown-Timer ist, keine Stoppuhr.
Terdon
ha du hast recht, das ist was ich wirklich wollte. Ich werde meine Benennung aktualisieren.
Tir38
3

Ich bin überrascht, dass niemand das sleepenhTool in seinen Skripten verwendet hat. Stattdessen verwenden die vorgeschlagenen Lösungen entweder eine sleep 1zwischen aufeinanderfolgenden Zeitgeberausgaben oder eine Besetztschleife, die so schnell wie möglich ausgibt. Ersteres ist unzureichend, da aufgrund der geringen Zeit, die für das Drucken aufgewendet wird, die Ausgabe nicht einmal pro Sekunde erfolgt, sondern etwas weniger als die suboptimale. Wenn genügend Zeit verstrichen ist, überspringt der Zähler eine Sekunde. Letzteres ist unzureichend, da die CPU ohne triftigen Grund ausgelastet ist.

Das Tool, das ich in meinem habe, $PATHsieht so aus:

#!/bin/sh
if [ $# -eq 0 ]; then
    TIMESTAMP=$(sleepenh 0)
    before=$(date +%s)
    while true; do
        diff=$(($(date +%s) - before))
        printf "%02d:%02d:%02d\r" $((diff/3600)) $(((diff%3600)/60)) $((diff%60))
        TIMESTAMP=$(sleepenh $TIMESTAMP 1.0);
    done
    exit 1 # this should never be reached
fi
echo "counting up to $@"
"$0" &
counterpid=$!
trap "exit" INT TERM
trap "kill 0" EXIT
sleep "$@"
kill $counterpid

Das Skript kann entweder als Stoppuhr (bis zur Unterbrechung hochgezählt) oder als Timer verwendet werden, der für die angegebene Zeitdauer ausgeführt wird. Da der sleepBefehl verwendet wird, können Sie mit diesem Skript die Dauer angeben, für die mit derselben Genauigkeit gezählt werden soll, wie Sie dies sleepzulassen. Unter Debian und Derivaten umfasst dies einen Ruhezustand von weniger als einer Sekunde und eine gut lesbare Möglichkeit, die Zeit anzugeben. So kann man zum Beispiel sagen:

$ time countdown 2m 4.6s
countdown 2m 4.6s  0.00s user 0.00s system 0% cpu 2:04.60 total

Und wie Sie sehen, lief der Befehl genau 2 Minuten und 4,6 Sekunden, ohne viel Magie im Skript selbst.

EDIT :

Das sleepenh-Tool stammt aus dem gleichnamigen Paket in Debian und seinen Derivaten wie Ubuntu. Für Distributionen, die es nicht haben, stammt es von https://github.com/nsc-deb/sleepenh

Der Vorteil von sleepenh ist, dass es in der Lage ist, die geringe Verzögerung zu berücksichtigen, die sich im Laufe der Zeit aus der Verarbeitung anderer Dinge als dem Schlaf während einer Schleife ergibt. Selbst wenn man nur sleep 110 Mal in einer Schleife wäre, würde die Gesamtausführung etwas mehr als 10 Sekunden dauern, da die Ausführung sleepund das Iterieren der Schleife einen geringen Mehraufwand verursachen . Dieser Fehler häufte sich langsam an und würde unsere Stoppuhr mit der Zeit immer ungenauer machen. Um dieses Problem zu beheben, muss für jede Schleifeniteration die genaue Ruhezeit berechnet werden, die normalerweise etwas kürzer als eine Sekunde ist (für Zeitintervalle von einer Sekunde). Das sleepenh-Tool erledigt dies für Sie.

josch
quelle
Ich verstehe nicht, welchen Nutzen dies gegenüber meiner ebenfalls verwendeten Antwort hat sleep 0.1. Was ist sleepnh(ich kann es nicht in den Arch-Repos finden) und wie unterscheidet es sich von sleep? Soweit ich das beurteilen kann, tun Sie im Grunde das Gleiche wie meine obige Antwort. Was vermisse ich?
Terdon
@terdon Sleepenh kommt von hier github.com/nsc-deb/sleepenh Das Problem sleep 5ist, dass Sie genau 5 Sekunden lang nicht schlafen. Versuchen Sie es zum Beispiel time sleep 5und Sie sehen, dass das Ausführen des Befehls etwas mehr als 5 Sekunden dauert. Im Laufe der Zeit häufen sich die Fehler. Mit dem Dienstprogramm sleepenh können Sie diese Häufung von Fehlern auf einfache Weise vermeiden.
josch
OKAY. Auf meinem System wird ein Fehler von 0,002 Sekunden angezeigt. Ich bezweifle wirklich, dass jemand diese Art von Tool verwenden würde und eine Genauigkeit von mehr als einer Millisekunde erwartet, aber es wäre besser, wenn Sie zumindest Ihre Antwort bearbeiten und erklären, warum dies sleepnhbesser ist als sleep(Sie sagen nur, dass andere Antworten sleep 1dies nicht tun) , nur das OP benutzt das) und ii), wo man es bekommt und wie man es installiert, da es kein Standardwerkzeug ist.
Terdon
1
@terdon Ich habe den Unterschied zwischen sleepund sleepenhim ersten Absatz erklärt. Jedenfalls war mir das wahrscheinlich nicht klar genug, so dass ich am Ende mehr darauf einging. Die Millisekunden-Genauigkeitsprobleme treten auf, wenn Sie sleepeinmal anrufen . Sie häufen sich mit der Zeit an und irgendwann ist dies bemerkbar. Ich habe nicht gesagt, dass andere nur verwenden sleep 1. Ich sagte, dass sie sleep 1oder eine Busyloop verwenden. Was sie immer noch tun. Zeigen Sie mir ein Gegenbeispiel. Die Antworten sleep 0.1sind die gleichen wie die, mit der sleep 1Ausnahme, dass sie Fehler noch schneller ansammeln.
josch
Ich ging die Antworten durch und suchte nach jemandem, der zumindest die Existenz des von Ihnen gelösten Problems anerkannte.
Mariotomo
2

Kurze Antwort:

for i in `seq 60 -1 1` ; do echo -ne "\r$i " ; sleep 1 ; done

Erläuterung:

Ich weiß, dass es viele Antworten gibt, aber ich möchte nur etwas sehr Nahes an der Frage von OP posten, die ich persönlich als " Oneliner Countdown im Terminal " akzeptieren würde . Meine Ziele waren:

  1. Einzeiler.
  2. Countdown.
  3. Einfach zu merken und Konsole einzutippen (keine Funktionen und viel Logik, nur Bash).
  4. Benötigt keine zusätzliche Software zur Installation (kann auf jedem Server verwendet werden, auf dem ich über ssh gehe, auch wenn ich dort kein Root-Verzeichnis habe).

Wie es funktioniert:

  1. seq druckt Zahlen von 60 bis 1.
  2. echo -ne "\r$i "Bringt das Caret an den Anfang der Zeichenkette zurück und gibt den aktuellen $iWert aus. Leerzeichen nach dem Überschreiben des vorherigen Werts, wenn dieser länger als der aktuelle Wert war $i(10 -> 9).
cronfy
quelle
1
Dies funktionierte am besten für meinen Anwendungsfall unter Mac OS zur Verwendung in einem Bash-Skript. Die Erklärung, wie es funktioniert, ist besonders hilfreich.
James Campbell
1

Zum späteren Nachschlagen gibt es ein Befehlszeilentool namens µTimer mit sehr einfachen Befehlszeilenoptionen für einen Countdown / Countup -Timer.

Tom
quelle
1

Stellen Sie sich als OSX-Benutzer vor, der nach einer Stoppuhr für die Befehlszeile sucht. Stellen Sie sich vor, Sie möchten die Gnu-Tools nicht installieren und nur mit dem Unix laufendate

in diesem Fall mache wie @terdon sagt, aber mit dieser Modifikation:

function stopwatch(){
    date1=`date +%s`; 
    while true; do 
        echo -ne "$(date -jf "%s" $((`date +%s` - $date1)) +%H:%M:%S)\r"; 
        sleep 0.1
    done
}
joem
quelle
1
Ich versuchte es auf OS X El Capitan, aus irgendeinem Grund mit 16.00.00 beginnt
nopole
1

Verwenden Sie einfach watch + date in UTC-Zeit. Sie können auch ein Paket für große Displays installieren ...

export now="`date +%s -u`";
watch -n 0,1 'date +%T -u -d @$((`date +%s` - $now ))'

#Big plain characters
watch -n 0,1 'date +%T -u -d @$((`date +%s` - $now )) | toilet -f mono12'

#Big empty charaters
watch -n 0,1 'date +%T -u -d @$((`date +%s` - $now )) | figlet -c -f big'

Versuch es!

Siehe auch http://www.cyberciti.biz/faq/create-large-colorful-text-banner-on-screen/

MUY Belgien
quelle
1

sw ist eine einfache Stoppuhr, die für immer läuft.

sw

Installieren

wget -q -O - http://git.io/sinister | sh -s -- -u https://raw.githubusercontent.com/coryfklein/sw/master/sw

Verwendungszweck

sw
 - start a stopwatch from 0, save start time in ~/.sw
sw [-r|--resume]
 - start a stopwatch from the last saved start time (or current time if no last saved start time exists)
 - "-r" stands for --resume
Cory Klein
quelle
1

Ein Python-Beispiel:

#!/usr/bin/python

def stopwatch ( atom = .01 ):
    import time, sys, math

    start = time.time()
    last = start
    sleep = atom/2
    fmt = "\r%%.%sfs" % (int(abs(round(math.log(atom,10))))  if atom<1 else "")
    while True:
        curr = time.time()
        subatom = (curr-last)
        if subatom>atom:
            # sys.stdout.write( "\r%.2fs" % (curr-start))
            sys.stdout.write( fmt % (curr-start))
            sys.stdout.flush()
            last = curr
        else:
            time.sleep(atom-subatom)

stopwatch()

Demo

user84207
quelle
1

Werfen Sie einen Blick auf TermTime , es ist eine schöne terminalbasierte Uhr und Stoppuhr:

pip install termtime

Vimist
quelle
0

Dies ist ähnlich wie die akzeptierte Antwort, aber Terdon countdown()hat mir Syntaxfehler gegeben. Dieser funktioniert jedoch hervorragend für mich:

function timer() { case "$1" in -s) shift;; *) set $(($1 * 60));; esac; local S=" "; for i in $(seq "$1" -1 1); do echo -ne "$S\r $i\r"; sleep 1; done; echo -e "$S\rTime's up!"; }

Sie können es .bashrceingeben und dann ausführen mit: timer t(wobei t die Zeit in Minuten ist).

Andy Forceno
quelle
0

Ich habe diese Frage heute früher gefunden, als ich nach einer Semesteranwendung suchte, um einen großen Countdown-Timer für einen Workshop anzuzeigen. Keiner der Vorschläge war genau das, was ich brauchte, also habe ich schnell einen anderen in Go: https://github.com/bnaucler/cdown zusammengestellt

Da die Frage bereits ausreichend beantwortet ist, halten Sie dies für die Nachwelt.

B Nauclér
quelle
0

$ sleep 1500 && xterm -fg gelb -g 240x80 &

Wenn das große Terminal mit dem gelben Text aufspringt, ist es Zeit aufzustehen und sich zu strecken!

Anmerkungen: - 1500 Sekunden = 25 Minuten Pomodoro - 240x80 = Terminalgröße mit 240 Zeichen und 80 Zeilen. Füllt einen Bildschirm für mich spürbar aus.

Bildnachweis: http://www.linuxquestions.org/questions/linux-newbie-8/countdown-timer-for-linux-949463/

user79878
quelle
0

Eine GUI-Version der Stoppuhr

date1=`date +%s`
date1_f=`date +%H:%M:%S____%d/%m`
(
  while true; do 
    date2=$(date -u --date @$((`date +%s` - $date1)) +%H:%M:%S)
    echo "# started at $date1_f \n$date2"
  done
) |
zenity --progress \
  --title="Stop Watch" \
  --text="Stop Watch..." \
  --percentage=0
Mohamed Samy
quelle
-2

Wenn Sie aus irgendeinem Grund ein kompilierbares Programm wünschen, funktioniert Folgendes:

#include <iostream>
#include <string>
#include <chrono>

int timer(seconds count) {
  auto t1 = high_resolution_clock::now();
  auto t2 = t1+count;
  while ( t2 > high_resolution_clock::now()) {
    std::cout << "Seconds Left:" <<
    std::endl <<
      duration_cast<duration<double>>(count-(high_resolution_clock::now()-t1)).count() << 
    std::endl << "\033[2A\033[K";
    std::this_thread::sleep_for(milliseconds(100));
  }
  std::cout << "Finished" << std::endl;
  return 0;
}

Dies kann auch in anderen Programmen verwendet und einfach portiert werden, wenn keine Bash-Umgebung verfügbar ist oder Sie nur ein kompiliertes Programm bevorzugen

Github

elder4222
quelle