Je ne sais pas pourquoi vous avez besoin de beep , si tout ce que vous voulez est un chronomètre, vous pouvez le faire:

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

Cela vous montrera les secondes qui passent en temps réel et vous pouvez l'arrêter avec Ctrl + C. Si vous avez besoin d'une plus grande précision, vous pouvez l'utiliser pour vous donner des nanosecondes:

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

Enfin, si vous voulez vraiment "format de chronomètre", où tout commence à 0 et commence à croître, vous pouvez faire quelque chose comme ça:

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

Pour un compte à rebours (ce qui n'est pas ce que votre question initiale posée), vous pouvez le faire (changez les secondes en conséquence):

 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 

Vous pouvez les combiner en commandes simples en utilisant les fonctions bash (ou celles que vous préférez). Dans bash, ajoutez ces lignes à votre ~/.bashrc (le sleep 0.1 fera que le système attendre 1 / 10ème de seconde entre chaque exécution afin que vous ne spammez pas votre CPU):

 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 } 

Vous pouvez ensuite lancer un compte à rebours d'une minute en exécutant:

 countdown 60 

Vous pouvez compter deux heures avec:

 countdown $((2*60*60)) 

Ou une journée entière en utilisant:

 countdown $((24*60*60)) 

Et lancez le chronomètre en exécutant:

 stopwatch 

Si vous devez être en mesure de gérer les jours ainsi que les heures, les minutes et les secondes, vous pourriez faire quelque chose comme ceci:

 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 } 

Notez que la fonction stopwatch n'a pas été testée pendant des jours car je ne voulais vraiment pas attendre 24 heures pour elle. Cela devrait fonctionner, mais s'il vous plaît, faites-le moi savoir si ce n'est pas le cas.

Ma façon préférée est:

Début:

 time cat 

Arrêtez:

 ctrl+c 

Comme @wjandrea commenté ci-dessous, une autre version est à exécuter:

 time read 

Et appuyez sur Enter pour arrêter

Je cherchais la même chose et finis par écrire quelque chose de plus élaboré dans Python:

Cela vous donnera un compte à rebours simple de 10 secondes:

 sudo pip install termdown termdown 10 

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

J'ai utilisé celui-ci:

 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 ) 

Exemple:

  countdown "00:07:55" 

Voici une source .

 sh-3.2# man leave 

Régler une minuterie pendant 15 minutes

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

Edit: J'ai eu un tas de liens ouverts, et je pensais que c'était spécifique à osx, désolé pour ça. Laisser ma réponse pour que d'autres soient conscients de l'abandon des BSD.

Ceci est pour un chronomètre avec des centièmes de seconde:

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

Exemple

J'ai combiné la très bonne réponse du terdon, en fonction qui, en même temps, affiche le temps depuis le début et l'heure jusqu'à la fin. Il y a aussi trois variantes, donc il est plus facile d'appeler (vous n'avez pas à faire des calculs bash), et il est également extrait. Exemple d'utilisation :

 { ~ } » 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 

Et quelque chose comme horloge de travail:

 { ~ } » 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 

Et si vous avez besoin d'un temps très précis:

 { ~ } » 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 

Voici le code à insérer dans votre .bashrc

 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]})) } 

Combinez ceci avec une certaine façon de jouer du son dans le terminal linux ( play mp3 ou fichier wav via la ligne de commande Linux ) ou cygwin ( cat /path/foo.wav > /dev/dsp fonctionne pour moi dans babun / win7) et vous avez un simple Temporisateur flexible avec alarme !

Une autre approche

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

Pour Mac:

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

Si l'on veut un signal quand il frappe à zéro, on pourrait, par exemple, le construire avec une commande qui a rendu un état de sortie non nul à zéro et le combiner avec la watch -b , ou quelque chose, mais si l'on veut construire un script plus élaboré, Ce n'est probablement pas le chemin à parcourir; Il s'agit plus d'une solution de type "rapide et sale".

J'aime le programme de watch en général. Je l'ai vu pour la première fois après que j'avais déjà écrit d'innombrables while sleep 5; do while sleep 5; do boucles à des effets différents. watch était manifestement plus agréable.

J'ai fini par écrire mon propre script shell: 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 (ie if time expired) then # blink screen for i in `seq 1 180`; # for i = 1:180 (ie 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" # (ie 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 

Pour une référence future, il existe un outil de ligne de commande appelé μTimer avec des options de ligne de commande très direct pour une temporisation de compte à rebours ou de compte à rebours.

Imaginez que vous êtes une personne sur OSX à la recherche d'un chronomètre de ligne de commande. Imaginez que vous ne souhaitez pas installer les outils gnu et que vous voulez simplement exécuter avec la date l'unix

Dans ce cas, comme le dit @terdon mais avec cette modification:

 function stopwatch(){ date1=`date +%s`; while true; do echo -ne "$(date -jf "%s" $((`date +%s` - $date1)) +%H:%M:%S)\r"; sleep 0.1 done } 

Je suis surpris que personne n'utilise l'outil sleepenh dans leurs scripts. Au lieu de cela, les solutions proposées utilisent soit le sleep 1 entre les sorties de minuterie ultérieures, soit une boucle occupée qui émet le plus rapidement possible. Le premier est inadéquat parce que, en raison du peu de temps consacré à l'impression, la sortie ne se produira pas réellement une fois par seconde, mais un peu moins que celle qui est sous-optimale. Après un temps suffisant, le compteur saute une seconde. Ce dernier est inadéquat parce qu'il maintient la CPU occupée pour une bonne raison.

L'outil que j'ai dans mon $PATH ressemble à ceci:

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

Le script peut être utilisé comme un chronomètre (compte jusqu'à jusqu'à l'interruption) ou comme une minuterie qui s'exécute pour le temps spécifié. Comme la commande sleep est utilisée, ce script permet de spécifier la durée à compter avec la même précision que votre sleep permet. Sur Debian et dérivés, cela inclut les sous-durées et une bonne façon lisible par l'homme de préciser l'heure. Ainsi, par exemple, vous pouvez dire:

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

Et comme vous pouvez le voir, la commande a fonctionné exactement pendant 2 minutes et 4,6 secondes sans beaucoup de magie dans le script lui-même.

EDIT :

L'outil sleepenh provient du paquet du même nom dans Debian et ses dérivés comme Ubuntu. Pour les distributions qui ne l'ont pas, elle vient de https://github.com/nsc-deb/sleepenh

L'avantage de sleepenh est qu'il est capable de tenir compte du petit retard qui s'accumule au fil du temps du traitement d'autres choses que le sommeil pendant une boucle. Même si l'on allait juste sleep 1 en boucle 10 fois, l'exécution globale prendrait un peu plus de 10 secondes en raison des petits frais généraux provenant de l'exécution du sleep et de l'itération de la boucle. Cette erreur s'accumule lentement et au fil du temps rendra notre chronomètre de plus en plus imprécis. Pour corriger ce problème, il faut que chaque itération en boucle calcule le temps précis de sommeil qui est habituellement légèrement inférieur à une seconde (pour une seconde temporisation d'intervalle). L'outil sleepenh le fait pour vous.

Sw est un chronomètre simple qui fonctionnera pour toujours.

Installer

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

Usage

 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 

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

Il suffit d'utiliser watch + date en UTC. Vous pouvez également installer un paquet pour un grand écran …

 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' 

Essayez-le!

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

Ceci est similaire à la réponse acceptée, mais le countdown() de Terdon countdown() m'a donné des erreurs de syntaxe. Celui-ci fonctionne très bien pour moi, cependant:

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!"; }

Vous pouvez le mettre dans .bashrc , puis exécuter avec: timer t (où t est le temps en minutes).

J'ai trouvé cette question plus tôt aujourd'hui, lors de la recherche d'une application à terme pour afficher un grand compte à rebours pour un atelier. Aucune des suggestions n'était exactement ce dont j'avais besoin, alors j'ai rapidement mis un autre dans Go: https://github.com/bnaucler/cdown

Comme la question est déjà suffisamment répondu, considérez ceci comme pour la postérité.

$ Sommeil 1500 && xterm -fg jaune -g 240×80 &

Lorsque ce grand terminal avec le texte jaune passe, le temps de se lever et de s'étirer!

Remarques: – 1500 secondes = 25 minutes pomodoro – 240×80 = taille de la borne avec une rangée de 240 caractères et 80 lignes. Pour moi, je trouve un écran visible.

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

Si vous souhaitez un programme compilable pour quelque raison que ce soit, ce qui suit:

 #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; } 

Cela peut également être utilisé dans d'autres programmes et facilement porté, si un environnement bash n'est pas disponible ou vous préférez simplement utiliser un programme compilé

Github