Creating a Pomodoro in Bash

I originally wanted to create a pomodoro timer that could run in i3status or i3blocks. I haven’t quite made it that far, but it does run in bash. For those of you who haven’t heard about it, see the Wikipedia article on the Pomodoro Technique.

I chose to create a work period of 25 minutes, with 5 minute short breaks and 20 minute long breaks. I decided to measure the time using a date object measured in seconds. Then I figured I needed three functions: 1) a compute function that takes an argument of seconds to start from and prints the number of seconds elapsed from that date object (measured in seconds), 2) a “convert seconds” function that takes a date object in seconds and returns the formated string of minutes and seconds that can be displayed to the user, and 3) a “seconds remaining” function that takes two arguments: the number of seconds when the period started and the “now” time in seconds, and that returns a printed string of remaining minutes and seconds in the period.

Further, I needed a function to run the breaks between work periods. This function would start a period for a certain length, and that length would be this functions only required parameter.

Once all this was working, I would need some kind of audible bell or something to tell the user when the Pomodoro period or break was done, and when to take a break or return to work. So that was another function.

Because I not only wanted this to run in a shell terminal, I wrote a function that would display the work periods (pomodoros) and break periods in a single line that could be displayed on a status bar like i3status or i3blocks for my favorite tiling window manager, i3wm. This required that I actually have two functions for showing a pomodoro, one that displays inside a terminal and one that runs inside a bar. Well, the “bar” function works such that it displays a line of text that could run inside a status bar, but I haven’t gotten it to actually work inside either i3bar or i3blocks. It displays inside a terminal on a single line just fine. And the other functions works fine inside a terminal window; it takes up about 5 lines of text, separated by line spaces in-between, for a total of ten line spaces.

Here’s the script:

#!/usr/bin/env bash

#################################
#  Easy little pomodoro time mgmt
#  program to help you not waste time.
#  This runs in a terminal, so you can use it 
#  with a tiling window manager if desired.
#  Requires 'play' is installed (from sox)
#################################

##  Initial variables
short_break=5
long_break=20
pomodoro=25
## Forgot that all terminals are not UTF
#goal="⌚⌚⌚⌚⌚⌚⌚⌚"
goal="********"
completed_pomodoros=""
start_sound=./sounds/Ship_Bell-Mike_Koenig-1911209136.wav
end_sound=./sounds/foghorn-daniel_simon.wav
((durationinmins=${pomodoro}*3600/60))

## Run the i3bar version or regular version?
[[ "$@" =~ 'b' ]] && runinbar=true || unset runinbar

##  Set the start time in seconds
start_time=$(date +%s)

## Play start or end sounds for periods
play_sound(){
   ## make sure 'play' is installed...
   command -v play >/dev/null 2>&1 || { echo >&2 "play (from sox app) is required but not installed. aborting..."; exit 1; } 
   file=${1}
   play -q $file 2>/dev/null
}

## Play the start sound
play_sound $start_sound

## Computes seconds elapsed from after 1st argument
## Expects argument in seconds
compute(){
  start_secs=${1}
  now_time=$(date +%s)
  elapsed=$( expr $now_time - $start_secs )
  printf "%d " "${elapsed}"
}

## Converts seconds to hours, minutes, seconds
## Just displays minutes and seconds
convertsecs(){
   ((h=${1}/3600))
   ((m=(${1}%3600)/60))
   ((s=${1}%60))
   #printf "%02d:%02d:%02d" $h $m $s
   printf "%02d:%02d" $m $s
}

## Computes minutes and seconds remaining from start time
## and now time,  Expects now_seconds then start_time
remainingsecs(){
   ((m=${2}-1-${1}%3600/60))
   ((s=(60-${1}%60)))
   [ $m -eq -1 ] && m=0
   printf "%02d:%02d" $m $s
}

## For showing a list of asterisks and completed Pomodoros
completed(){
   echo '⌚' 
}

##  Runs a break, either a short one or long one
##  Expects an argument in minutes
run_break(){
   play_sound $end_sound
   start=$(date +%s)
   now=$(date +%s)
   length=${1}
   elapsed_secs=$(expr $now - $start)
   minutes=$((elapsed_secs/60))



   while [ $minutes -le $length ]; do
       now=$(date +%s)
       pomo=$(compute $start)
       minutes=$((elapsed_secs/60))

       ## exit and start a new Pomodoro when break is spent
       if (($minutes >= $length)) ; then 
           return 0
       fi

       elapsed_secs=$(expr $now - $start)
       remaining=$(remainingsecs $elapsed_secs $length)
       elapsed=$(convertsecs $pomo)
       if [ $length -ne $short_break ]; then
           break_type="Long Break"
       else
           break_type="Short Break"
       fi

       clear
## Hot pink may not work well on light terminal but it does on dark terminal
cat <<EOBreak


       $(echo -e "\033[38;5;205m")
       //////////////////////   BREAK TIME  //////////////////////////////

       Break: ${break_type}    Elapsed: ${elapsed}   Remaining:  ${remaining}
       $(echo -e "\033[m")

EOBreak

       sleep 1
   done
}

show_bar(){
   count=0
   period=${1}
   length=${2}
   start=$(date +%s)
   spinner=('\' '|' '/' '—' '\' '|' '/' '—')


   while true; do
       elapsedsecs=$(compute $start)
       [ ${elapsedsecs} -gt $((length*60)) ] && return
       pomo=$(compute $start)
       elapsed=$(convertsecs $pomo)
       remaining=$(remainingsecs $pomo $length)
       clear
       printf "%s > %s %ss left %d/%d done" ${period} ${spinner[$count]} ${remaining} ${#completed_pomodoros} ${#goal} 
       sleep 1
       if [ $count -lt 7 ]; then
           ((count++))
       else
           count=0
       fi
   done

}

##  This is the main pomodoro screen
show_pom(){
   period=${1}
   length=${2}
   start=$(date +%s)

   while true; do
       pomo=$(compute $start)
       elapsedsecs=$(compute $start)
       [ ${elapsedsecs} -gt $((length*60)) ] && return
       elapsed=$(convertsecs $pomo)
       remaining=$(remainingsecs $pomo $length)

   clear

cat <<EOF


                   Welcome to MyPomodoro!

       ///////////////  Work Time  ///////////////////////

       Short break: ${short_break}     Elapsed: ${elapsed}

       Long break: ${long_break}     Remaining: ${remaining}

       Goal: ${goal}     Completed: ${completed_pomodoros}
EOF
   sleep 1
   done
}
   

##  This is the main loop
while true; do
   [ "$runinbar" ] && show_bar "Work" ${pomodoro} || show_pom "Work" ${pomodoro}

   completed_pomodoros+=$(completed)
   if  [[  $(( ${#completed_pomodoros} % 4 )) == 0 ]] && [[ ${#completed_pomodoros} -ne 0 ]]; then
       [ "$runinbar" ] && play_sound $end_sound && show_bar "Long_Break" ${long_break} || run_break ${long_break}
   else
       [ "$runinbar" ] && play_sound $end_sound && show_bar "Short_Break" ${short_break} || run_break ${short_break}
   fi
   start_time=$(date +%s)
   play_sound $start_sound
done

Thoughts on Script

I’m not sure this script will stand, but it seems to work for now. The idea was to pass a ‘-b’ argument if it should run in the bar, and pass no arguments if it should just run in the terminal. So far, it just runs in the terminal, either in a single line or on multiple lines.

Also, I thought I could paste in little watch glyphs using Unicode characters, but then those didn’t show up on some of my simpler terminal emulators. So I went back to just using asterisks.

There was also the need to check whether the Sox ‘play’ command was installed and issue a warning if it wasn’t. The command -v command was of use here.

The entire script relies on a while loop at the bottom of the script, which calls the other functions as required.

Pause?

Strictly speaking, I don’t think I need a pause command. The whole idea of Pomodoro is to concentrate on what you’re doing and not get side tracked. If the phone rings, let the caller leave a message. If wifey texts, look at it during a break. If your kid is stuck by the side of the road, then handle it during a break. If your boss interrupts you, well, then it’s up to you how you handle it. But it seems to me that adding a pause function is counter-intuitive to what the Pomodoro Technique is all about. What do you think?

Going Forward

I really want to get this running in i3blocks. I’m not sure whether it’s possible to get it running in i3status. So far no luck. I’ll keep at it.

I’ve still got some comments in the code to remind me to think about things, like the ‘goal’ string variable. Is there a way to display the unicode characters for hourglass or watch in Urxvt for example? Not sure yet.

I think Sox is a pretty universal sound player. It rarely comes pre-packaged with Linux distributions anymore, but I think it’s available in almost all repos, and has few if any dependencies.

This little application has already taken a surprising amount of time to complete thus far. And it still doesn’t run in i3blocks! But I’ve been using it for my productivity in using i3wm, and it’s easy to run inside of a narrow terminal.

Hopefully, I’ll get it running inside i3blocks real soon now!