Come posso visualizzare un timer per il conto alla rovescia in tempo reale sul terminale Linux? C'è un'applicazione esistente o, ancora meglio, un one liner per fare questo?
Non sono sicuro del perché tu abbia bisogno di beep, se tutto quello che vuoi è un cronometro, puoi fare così:
while true; do echo -ne "`date`\r"; done
Che vi mostrerà i secondi che passano in tempo reale e potete fermarlo con Ctrl+C. Se avete bisogno di maggiore precisione, potete usare questo per darvi i nanosecondi:
while true; do echo -ne "`date +%H:%M:%S:%N`\r"; done
Infine, se volete davvero, davvero il “formato cronometro”, dove tutto parte da 0 e inizia a crescere, potreste fare qualcosa come questo:
date1=`date +%s`; while true; do
echo -ne "$(date -u --date @$((`date +%s` - $date1)) +%H:%M:%S)\r";
done
Per un timer per il conto alla rovescia (che non è quello che la tua domanda originale chiedeva) potresti fare così (cambia i secondi di conseguenza):
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
Puoi combinare questi in semplici comandi usando le funzioni di bash (o qualsiasi shell tu preferisca). In bash, aggiungete queste linee al vostro ~/.bashrc (lo sleep 0.1 farà attendere il sistema per 1/10 di secondo tra ogni esecuzione in modo da non spammare la 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
}
Puoi quindi avviare un timer per il conto alla rovescia di un minuto eseguendo:
countdown 60
Puoi fare un conto alla rovescia di due ore con:
countdown $((2*60*60))
o un giorno intero usando:
countdown $((24*60*60))
E avviare il cronometro eseguendo:
stopwatch
Se avete bisogno di poter gestire i giorni oltre a ore, minuti e secondi, potreste fare qualcosa del genere:
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
}
Nota che la funzione stopwatch non è stata testata per i giorni poiché non volevo aspettare 24 ore. Dovrebbe funzionare, ma per favore fatemi sapere se non funziona.
sh-3.2# man leave
impostare un timer per 15 minuti
sh-3.2# leave +0015
Alarm set for Thu Nov 3 14:19:31 CDT 2016. (pid 94317)
sh-3.2#
edit: Avevo un mucchio di link aperti, e pensavo che questo fosse specifico per osx, mi dispiace. Lascio la mia risposta in alto in modo che gli altri siano consapevoli di lasciare sui BSD.
Ho usato questo:
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
)
Esempio:
countdown "00:07:55"
Ecco una fonte .
Questo è per un cronometro con centesimi di secondo:
#!/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
}
}
Risposta breve:
for i in `seq 60 -1 1` ; do echo -ne "\r$i " ; sleep 1 ; done
Spiegazione:
So che ci sono molte risposte, ma voglio solo postare qualcosa di molto vicino alla domanda dell'OP, che personalmente accetterei come davvero “ conteggio alla rovescia nel terminale”. I miei obiettivi erano:
Come funziona:
seq stampa numeri da 60 a 1. echo -ne "\r$i " riporta il cursore all'inizio della stringa e stampa il valore corrente di $i. Lo spazio dopo di esso è necessario per sovrascrivere il valore precedente, se era più lungo di caratteri dell'attuale $i (10 -> 9).Ho combinato la risposta dell'ottimo terdon, in una funzione che allo stesso tempo visualizza il tempo dall'inizio, e il tempo fino alla fine. Ci sono anche tre varianti in modo che sia più facile da chiamare (non devi fare la matematica bash), ed è anche astratto. Esempio di utilizzo :
{ ~ } » 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
E qualcosa come timer di lavoro:
{ ~ } » 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
E se avete bisogno di un tempo molto specifico:
{ ~ } » 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
Ecco il codice da mettere nel vostro . 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]}))
}
Combinate questo con qualche modo di suonare nel terminale linux riprodurre file mp3 o wav tramite la linea di comando Linux ) o cygwin (cat /path/foo.wav > /dev/dsp funziona per me in babun/win7) e avrete un semplice timer flessibile con allarme!
Ho finito per scrivere il mio script di 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 (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
Sono sorpreso che nessuno abbia usato lo strumento sleepenh nei loro script. Invece, le soluzioni proposte o usano un sleep 1 tra le uscite successive del timer o un ciclo occupato che emette il più velocemente possibile. La prima è inadeguata perché a causa del poco tempo speso per fare la stampa, l'uscita non avverrà effettivamente una volta al secondo ma un po’ meno di quella, il che è subottimale. Dopo che è passato abbastanza tempo, il contatore salterà un secondo. Quest'ultimo è inadeguato perché tiene occupata la CPU senza una buona ragione.
Lo strumento che ho nel mio $PATH si presenta così:
#!/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
Lo script può essere usato come un cronometro (contando fino a quando non viene interrotto) o come un timer che funziona per la quantità di tempo specificata. Poiché viene usato il comando sleep, questo script permette di specificare la durata per la quale contare con la stessa precisione consentita da sleep. Su Debian e derivate, questo include gli sleep sub-secondi e un bel modo leggibile dall'uomo per specificare il tempo. Così, per esempio, potete dire:
$ time countdown 2m 4.6s
countdown 2m 4.6s 0.00s user 0.00s system 0% cpu 2:04.60 total
E come potete vedere, il comando ha funzionato esattamente per 2 minuti e 4,6 secondi senza molta magia nello script stesso.
EDIT :
Lo strumento sleepenh proviene dall'omonimo pacchetto in Debian e nelle sue derivate come Ubuntu. Per le distribuzioni che non ce l'hanno, viene da https://github.com/nsc-deb/sleepenh
Il vantaggio di sleepenh è che è in grado di tenere conto del piccolo ritardo che si accumula nel tempo dall'elaborazione di altre cose rispetto allo sleep durante un ciclo. Anche se uno facesse solo sleep 1 in un ciclo 10 volte, l'esecuzione complessiva richiederebbe un po’ più di 10 secondi a causa del piccolo overhead che deriva dall'esecuzione di sleep e dall'iterazione del ciclo. Questo errore si accumula lentamente e nel tempo renderebbe il nostro cronometro sempre più impreciso. Per risolvere questo problema, si deve calcolare ad ogni iterazione del ciclo il tempo preciso per dormire, che di solito è un po’ meno di un secondo (per timer con intervallo di un secondo). Lo strumento sleepenh fa questo per voi.
Un altro approccio
countdown=60 now=$(date +%s) watch -tpn1 echo '$((now-$(date +%s)+countdown))'
Per Mac:
countdown=60 now=$(date +%s) watch -tn1 echo '$((now-$(date +%s)+countdown))'
#no p option on mac for watch
Se si vuole un segnale quando arriva a zero, si potrebbe ad esempio costruire con un comando che restituisca uno stato di uscita non nullo a zero e combinarlo con watch -b, o qualcosa del genere, ma se si vuole costruire uno script più elaborato, questa probabilmente non è la strada da seguire; è più una soluzione del tipo “quick and dirty one-liner”.
Mi piace il programma watch in generale. L'ho visto per la prima volta dopo aver già scritto innumerevoli loop while sleep 5; do per diversi effetti. watch era dimostrabilmente più bello.
sw è un semplice cronometro che funzionerà per sempre.
wget -q -O - http://git.io/sinister | sh -s -- -u https://raw.githubusercontent.com/coryfklein/sw/master/sw
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
Fate finta di essere una persona su OSX che cerca un cronometro da linea di comando. Fate finta di non voler installare gli strumenti di Gnu e di voler solo funzionare con l'unix date
in questo caso fate come dice @terdon ma con questa modifica:
function stopwatch(){
date1=`date +%s`;
while true; do
echo -ne "$(date -jf "%s" $((`date +%s` - $date1)) +%H:%M:%S)\r";
sleep 0.1
done
}
Basta usare l'orologio + la data in ora UTC. Puoi anche installare qualche pacchetto per una grande visualizzazione…
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'
Prova!
Vedi anche http://www.cyberciti.biz/faq/create-large-colorful-text-banner-on-screen/
Un esempio python:
#!/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()
Una versione GUI del cronometro
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
Ho trovato questa domanda oggi, mentre cercavo un'applicazione a termine per visualizzare un grande timer per il conto alla rovescia per un workshop. Nessuno dei suggerimenti era esattamente quello di cui avevo bisogno, quindi ne ho rapidamente messo insieme un altro in Go: https://github.com/bnaucler/cdown
Visto che la domanda ha già una risposta sufficiente, considerala per i posteri.
$ sleep 1500 && xterm -fg yellow -g 240x80 &
Quando quel grande terminale con il testo giallo salta, è ora di alzarsi e fare stretching!
Note: - 1500 secondi = 25 minuti di pomodoro - 240x80 = dimensione del terminale con riga di 240 caratteri, e 80 righe. Riempie sensibilmente uno schermo per me.
Credito: http://www.linuxquestions.org/questions/linux-newbie-8/countdown-timer-for-linux-949463/
Questo è simile alla risposta accettata, ma terdon’s countdown() mi dava errori di sintassi. Questa però funziona benissimo per me:
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!"; }
Si può mettere in .bashrc e poi eseguire con: timer t (dove t è il tempo in minuti).
Se volete un programma compilabile per qualsiasi motivo, il seguente funzionerebbe:
#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 << "0x1&33[2A0x1&33[K";
std::this_thread::sleep_for(milliseconds(100));
}
std::cout << "Finished" << std::endl;
return 0;
}
Questo può essere usato anche in altri programmi e facilmente portato, se un ambiente bash non è disponibile o semplicemente preferite usare un programma compilato github