Nautical bell: Difference between revisions

From Rosetta Code
Content added Content deleted
(→‎{{header|J}}: improve comments in callWatch)
(→‎{{header|Java}}: added Java)
Line 305: Line 305:


'''Notes''': I tested the <tt>clock2ship</tt>, <tt>callWatch</tt>, and <tt>ringBell</tt> functions, but didn't actually have the patience to test <tt>shipsWatch</tt> over a 24-hour period. Use at your own risk (but don't use it to keep watch on your galleon, please).
'''Notes''': I tested the <tt>clock2ship</tt>, <tt>callWatch</tt>, and <tt>ringBell</tt> functions, but didn't actually have the patience to test <tt>shipsWatch</tt> over a 24-hour period. Use at your own risk (but don't use it to keep watch on your galleon, please).

=={{header|Java}}==
This code uses UTC time.
{{trans|D}}
<lang java>import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.TimeZone;

public class NauticalBell extends Thread {

public static void main(String[] args) {
NauticalBell bells = new NauticalBell();
bells.setDaemon(true);
bells.start();
try {
bells.join();
} catch (InterruptedException e) {
System.out.println(e);
}
}

@Override
public void run() {
DateFormat sdf = new SimpleDateFormat("HH:mm:ss");
sdf.setTimeZone(TimeZone.getTimeZone("UTC"));

int numBells = 0;
long time = System.currentTimeMillis();
long next = time - (time % (24 * 60 * 60 * 1000)); // midnight

while (next < time) {
next += 30 * 60 * 1000; // 30 minutes
numBells = 1 + (numBells % 8);
}

long wait = 0;
while (true) {
time = System.currentTimeMillis();
if (time - next >= 0) {
String bells = numBells == 1 ? "bell" : "bells";
String timeString = sdf.format(time);
System.out.printf("%s : %d %s\n", timeString, numBells, bells);
next += 30 * 60 * 1000;
wait = next - time;
numBells = 1 + (numBells % 8);
}
try {
Thread.sleep(wait);
} catch (InterruptedException e) {
System.out.println(e);
}
}
}
}</lang>

Sample output:

<pre>...
13:00:00 : 2 bells
13:30:00 : 3 bells
14:00:00 : 4 bells
...</pre>


=={{header|Perl 6}}==
=={{header|Perl 6}}==

Revision as of 14:24, 31 May 2014

Task
Nautical bell
You are encouraged to solve this task according to the task description, using any language you may know.

The task is to write a small program that emulates a nautical bell producing a ringing bell pattern at certain times throughout the day. The bell timing should be in accordance with Greenwich Mean Time, unless locale dictates otherwise.

It is permissible for the program to daemonize, or to slave off a scheduler, and it is permissible to use alternative notification methods (such as producing a written notice "Two Bells Gone"), if these are more usual for the system type.

Cf.

C++

This version uses local time. <lang cpp>

  1. include <iostream>
  2. include <string>
  3. include <windows.h>

//-------------------------------------------------------------------------------------------------- using namespace std;

//-------------------------------------------------------------------------------------------------- class bells { public: 

   void start()
   {

watch[0] = "Middle"; watch[1] = "Morning"; watch[2] = "Forenoon"; watch[3] = "Afternoon"; watch[4] = "Dog"; watch[5] = "First"; count[0] = "One"; count[1] = "Two"; count[2] = "Three"; count[3] = "Four"; count[4] = "Five"; count[5] = "Six"; count[6] = "Seven"; count[7] = "Eight"; _inst = this; CreateThread( NULL, 0, bell, NULL, 0, NULL ); 

   }

private: 

   static DWORD WINAPI bell( LPVOID p )
   {

DWORD wait = _inst->waitTime(); while( true ) { Sleep( wait ); _inst->playBell(); wait = _inst->waitTime(); } return 0; 

   }

   DWORD waitTime() 
   {

GetLocalTime( &st ); int m = st.wMinute >= 30 ? st.wMinute - 30 : st.wMinute; return( 1800000 - ( ( m * 60 + st.wSecond ) * 1000 + st.wMilliseconds ) ); 

   }

   void playBell()
   {

GetLocalTime( &st ); int b = ( 2 * st.wHour + st.wMinute / 30 ) % 8; b = b == 0 ? 8 : b; int w = ( 60 * st.wHour + st.wMinute ); if( w < 1 ) w = 5; else w = ( w - 1 ) / 240; char hr[32]; wsprintf( hr, "%.2d:%.2d", st.wHour, st.wMinute );

cout << hr << " - " << watch[w] << " watch - " << count[b - 1] << " Bell"; if( b > 1 ) cout << "s"; else cout << " "; cout << " Gone." << endl;

for( int x = 0, c = 1; x < b; x++, c++ ) { cout << "\7"; Sleep( 500 ); if( !( c % 2 ) ) Sleep( 300 ); } 

   }

   SYSTEMTIME st;
   string watch[7], count[8];
   static bells* _inst;

}; //-------------------------------------------------------------------------------------------------- bells* bells::_inst = 0; //-------------------------------------------------------------------------------------------------- int main( int argc, char* argv[] ) { 

   bells b; b.start();
   while( 1 ); // <- runs forever!
   return 0;

} //-------------------------------------------------------------------------------------------------- </lang> Output: 

00:00 - First watch - Eight Bells Gone.
00:30 - Middle watch - One Bell  Gone.
01:00 - Middle watch - Two Bells Gone.
01:30 - Middle watch - Three Bells Gone.
02:00 - Middle watch - Four Bells Gone.
02:30 - Middle watch - Five Bells Gone.
03:00 - Middle watch - Six Bells Gone.
03:30 - Middle watch - Seven Bells Gone.
04:00 - Middle watch - Eight Bells Gone.
04:30 - Morning watch - One Bell  Gone.
05:00 - Morning watch - Two Bells Gone.
05:30 - Morning watch - Three Bells Gone.
06:00 - Morning watch - Four Bells Gone.
06:30 - Morning watch - Five Bells Gone.
07:00 - Morning watch - Six Bells Gone.
07:30 - Morning watch - Seven Bells Gone.
08:00 - Morning watch - Eight Bells Gone.
08:30 - Forenoon watch - One Bell  Gone.
09:00 - Forenoon watch - Two Bells Gone.
09:30 - Forenoon watch - Three Bells Gone.
10:00 - Forenoon watch - Four Bells Gone.
10:30 - Forenoon watch - Five Bells Gone.
11:00 - Forenoon watch - Six Bells Gone.
11:30 - Forenoon watch - Seven Bells Gone.
12:00 - Forenoon watch - Eight Bells Gone.
12:30 - Afternoon watch - One Bell  Gone.
13:00 - Afternoon watch - Two Bells Gone.
13:30 - Afternoon watch - Three Bells Gone.
14:00 - Afternoon watch - Four Bells Gone.
14:30 - Afternoon watch - Five Bells Gone.
15:00 - Afternoon watch - Six Bells Gone.
15:30 - Afternoon watch - Seven Bells Gone.
16:00 - Afternoon watch - Eight Bells Gone.
16:30 - Dog watch - One Bell  Gone.
17:00 - Dog watch - Two Bells Gone.
17:30 - Dog watch - Three Bells Gone.
18:00 - Dog watch - Four Bells Gone.
18:30 - Dog watch - Five Bells Gone.
19:00 - Dog watch - Six Bells Gone.
19:30 - Dog watch - Seven Bells Gone.
20:00 - Dog watch - Eight Bells Gone.
20:30 - First watch - One Bell  Gone.
21:00 - First watch - Two Bells Gone.
21:30 - First watch - Three Bells Gone.
22:00 - First watch - Four Bells Gone.
22:30 - First watch - Five Bells Gone.
23:00 - First watch - Six Bells Gone.
23:30 - First watch - Seven Bells Gone.

D

This code uses local time instead of Greenwich Mean Time. <lang d>import std.stdio, core.thread, std.datetime;

class NauticalBell : Thread { 

   private shared bool stopped;

   this() {
       super(&run);
   }

   void run() {
       uint numBells;
       auto time = cast(TimeOfDay)Clock.currTime();
       auto next = TimeOfDay();

       void setNextBellTime() {
           next += minutes(30);
           numBells = 1 + (numBells % 8);
       }

       while (next < time)
           setNextBellTime();

       while (!this.stopped) {
           time = cast(TimeOfDay)Clock.currTime();
           if (next.minute == time.minute &&
                   next.hour == time.hour) {
               immutable bells = numBells == 1 ? "bell" : "bells";
               writefln("%s : %d %s", time, numBells, bells);
               setNextBellTime();
           }
           sleep(dur!"msecs"(100));
           yield();
        }
    }

    void stop() {
       this.stopped = true;
    }

}

void main() { 

   auto bells = new NauticalBell();
   bells.isDaemon(true);
   bells.start();
   try {
       bells.join();
   } catch (ThreadException e) {
       writeln(e.msg);
   }

}</lang> This output is from an actual test run. 

09:30:00 : 3 bells
10:00:00 : 4 bells
10:30:00 : 5 bells
11:00:00 : 6 bells
11:30:00 : 7 bells
12:00:00 : 8 bells
12:30:00 : 1 bell
13:00:00 : 2 bells
13:30:00 : 3 bells
14:00:00 : 4 bells
14:30:00 : 5 bells
15:00:00 : 6 bells
15:30:00 : 7 bells
16:00:00 : 8 bells
16:30:00 : 1 bell
17:00:00 : 2 bells
17:30:00 : 3 bells
18:00:00 : 4 bells
18:30:00 : 5 bells
19:00:00 : 6 bells
19:30:00 : 7 bells
20:00:00 : 8 bells
20:30:00 : 1 bell
21:00:00 : 2 bells
21:30:00 : 3 bells
22:00:00 : 4 bells
22:30:00 : 5 bells
23:00:00 : 6 bells
23:30:00 : 7 bells
00:00:00 : 8 bells
00:30:00 : 1 bell
01:00:00 : 2 bells
01:30:00 : 3 bells
02:00:00 : 4 bells
02:30:00 : 5 bells
03:00:00 : 6 bells
03:30:00 : 7 bells
04:00:00 : 8 bells
04:30:00 : 1 bell
05:00:00 : 2 bells
05:30:00 : 3 bells
06:00:00 : 4 bells
06:30:00 : 5 bells
07:00:00 : 6 bells
07:30:00 : 7 bells
08:00:00 : 8 bells
08:30:00 : 1 bell
09:00:00 : 2 bells

J

Translation of: Perl6

Solution:<lang j>require 'strings printf'

WATCH =: <;._1 ' Middle Morning Forenoon Afternoon Dog First' ORDINAL =: <;._1 ' One Two Three Four Five Six Seven Eight' BELL =: 7{a. NB. Terminal bell code (\a or ^G)

time =: 6!:0 sleep =: 6!:3 print =: ucp 1!:2 4:

shipsWatch =: verb define PREV_MARK =. _1 _1 while. do. NB. Loop forever now =. 3 4 { time NB. Current hour & minute

NB. If we just flipped over to a new half-hour mark if. (0 30 e.~ {: now) > now -: PREV_MARK do. PREV_MARK =. now 'allsWell notes'=.callWatch now

print allsWell (ringBell"0~ -@# {. 2|#) notes print CRLF end.

sleep 15.0 end. )

callWatch =: verb define 'watch bells' =. clock2ship y

NB. Plural for 0~:bells ordinals are origin-1, not origin-0 NB. (and similarly 1+bells for notes). fields=.(0{y);(1{y);(watch{::WATCH);(bells{::ORDINAL);('s'#~0~:bells) notes =. ; (0 2#:1+bells) #&.> u:16b266b 16b266a NB. ♫♪

notes ;~ '%02d:%02d %s watch, %s Bell%s Gone: \t' sprintf fields )

clock2ship =: verb define"1 NB. Convert from "24 hours of 60 minutes" to NB. "6 watches of 8 bells", and move midnight NB. from index-origin 0 (0 hrs, 0 minutes) NB. index-origin 1 (0 watches, 1 bell). 6 8 #: 48 | _1 + 24 2 #. (, (30-1)&I.)/ y )

ringBell =: dyad define print BELL,y

NB. x indicates two rings (0) or just one (1) if. 0=x do. sleep 0.75 print BELL sleep 0.25 else. sleep 1.0 end. y )</lang>

Examples: Invoke shipsWatch 0; the output is identical to Perl6's.

Notes: I tested the clock2ship, callWatch, and ringBell functions, but didn't actually have the patience to test shipsWatch over a 24-hour period. Use at your own risk (but don't use it to keep watch on your galleon, please).

Java

This code uses UTC time.

Translation of: D

<lang java>import java.text.DateFormat; import java.text.SimpleDateFormat; import java.util.TimeZone;

public class NauticalBell extends Thread { 

   public static void main(String[] args) {
       NauticalBell bells = new NauticalBell();
       bells.setDaemon(true);
       bells.start();
       try {
           bells.join();
       } catch (InterruptedException e) {
           System.out.println(e);
       }
   }

   @Override
   public void run() {
       DateFormat sdf = new SimpleDateFormat("HH:mm:ss");
       sdf.setTimeZone(TimeZone.getTimeZone("UTC"));

       int numBells = 0;
       long time = System.currentTimeMillis();
       long next = time - (time % (24 * 60 * 60 * 1000)); // midnight

       while (next < time) {
           next += 30 * 60 * 1000; // 30 minutes
           numBells = 1 + (numBells % 8);
       }

       long wait = 0;
       while (true) {
           time = System.currentTimeMillis();
           if (time - next >= 0) {
               String bells = numBells == 1 ? "bell" : "bells";
               String timeString = sdf.format(time);
               System.out.printf("%s : %d %s\n", timeString, numBells, bells);
               next += 30 * 60 * 1000;
               wait = next - time;
               numBells = 1 + (numBells % 8);
           }
           try {
               Thread.sleep(wait);
           } catch (InterruptedException e) {
               System.out.println(e);
           }
       }
   }

}</lang>

Sample output: 

...
13:00:00 : 2 bells
13:30:00 : 3 bells
14:00:00 : 4 bells
...

Perl 6

Perl 6 uses UTC (GMT) time internally and by default. This will display the current UTC time and on the half hour, display a graphical representation of the bell. If run in a terminal with the system bell enabled, will also chime the system alarm bell.

<lang perl6>my @watch = <Middle Morning Forenoon Afternoon Dog First>; my @ordinal = <One Two Three Four Five Six Seven Eight>;

my $thishour; my $thisminute = ;

loop { 

   my $utc = DateTime.new(time);
   if $utc.minute ~~ any(0,30) and $utc.minute != $thisminute {
       $thishour   = $utc.hour;
       $thisminute = $utc.minute;
       bell($thishour, $thisminute);
   }
   printf "%s%02d:%02d:%02d", "\r", $utc.hour, $utc.minute, $utc.second;
   sleep(1);

}

sub bell ($hour, $minute) { 

   my $bells = (($hour % 4) * 2 + $minute div 30) || 8;

   printf "%s%02d:%02d %9s watch, %6s Bell%s Gone: \t", "\b" x 9, $hour, $minute,
     @watch[($hour div 4 - !?($minute + $hour % 4) + 6) % 6],
     @ordinal[$bells - 1], $bells == 1 ??  !! 's';

   chime($bells);

   sub chime ($count) {

for 1..$count div 2 { print "\a♫ "; sleep .25; print "\a"; sleep .75; } if $count % 2 { print "\a♪"; sleep 1; 

       }
       print "\n";
   }

}</lang>

Output:
00:00     First watch,  Eight Bells Gone: 	♫ ♫ ♫ ♫ 
00:30    Middle watch,    One Bell Gone: 	♪
01:00    Middle watch,    Two Bells Gone: 	♫ 
01:30    Middle watch,  Three Bells Gone: 	♫ ♪
02:00    Middle watch,   Four Bells Gone: 	♫ ♫ 
02:30    Middle watch,   Five Bells Gone: 	♫ ♫ ♪
03:00    Middle watch,    Six Bells Gone: 	♫ ♫ ♫ 
03:30    Middle watch,  Seven Bells Gone: 	♫ ♫ ♫ ♪
04:00    Middle watch,  Eight Bells Gone: 	♫ ♫ ♫ ♫ 
04:30   Morning watch,    One Bell Gone: 	♪
05:00   Morning watch,    Two Bells Gone: 	♫ 
05:30   Morning watch,  Three Bells Gone: 	♫ ♪
06:00   Morning watch,   Four Bells Gone: 	♫ ♫ 
06:30   Morning watch,   Five Bells Gone: 	♫ ♫ ♪
07:00   Morning watch,    Six Bells Gone: 	♫ ♫ ♫ 
07:30   Morning watch,  Seven Bells Gone: 	♫ ♫ ♫ ♪
08:00   Morning watch,  Eight Bells Gone: 	♫ ♫ ♫ ♫ 
08:30  Forenoon watch,    One Bell Gone: 	♪
09:00  Forenoon watch,    Two Bells Gone: 	♫ 
09:30  Forenoon watch,  Three Bells Gone: 	♫ ♪
10:00  Forenoon watch,   Four Bells Gone: 	♫ ♫ 
10:30  Forenoon watch,   Five Bells Gone: 	♫ ♫ ♪
11:00  Forenoon watch,    Six Bells Gone: 	♫ ♫ ♫ 
11:30  Forenoon watch,  Seven Bells Gone: 	♫ ♫ ♫ ♪
12:00  Forenoon watch,  Eight Bells Gone: 	♫ ♫ ♫ ♫ 
12:30 Afternoon watch,    One Bell Gone: 	♪
13:00 Afternoon watch,    Two Bells Gone: 	♫ 
13:30 Afternoon watch,  Three Bells Gone: 	♫ ♪
14:00 Afternoon watch,   Four Bells Gone: 	♫ ♫ 
14:30 Afternoon watch,   Five Bells Gone: 	♫ ♫ ♪
15:00 Afternoon watch,    Six Bells Gone: 	♫ ♫ ♫ 
15:30 Afternoon watch,  Seven Bells Gone: 	♫ ♫ ♫ ♪
16:00 Afternoon watch,  Eight Bells Gone: 	♫ ♫ ♫ ♫ 
16:30       Dog watch,    One Bell Gone: 	♪
17:00       Dog watch,    Two Bells Gone: 	♫ 
17:30       Dog watch,  Three Bells Gone: 	♫ ♪
18:00       Dog watch,   Four Bells Gone: 	♫ ♫ 
18:30       Dog watch,   Five Bells Gone: 	♫ ♫ ♪
19:00       Dog watch,    Six Bells Gone: 	♫ ♫ ♫ 
19:30       Dog watch,  Seven Bells Gone: 	♫ ♫ ♫ ♪
20:00       Dog watch,  Eight Bells Gone: 	♫ ♫ ♫ ♫ 
20:30     First watch,    One Bell Gone: 	♪
21:00     First watch,    Two Bells Gone: 	♫ 
21:30     First watch,  Three Bells Gone: 	♫ ♪
22:00     First watch,   Four Bells Gone: 	♫ ♫ 
22:30     First watch,   Five Bells Gone: 	♫ ♫ ♪
23:00     First watch,    Six Bells Gone: 	♫ ♫ ♫ 
23:30     First watch,  Seven Bells Gone: 	♫ ♫ ♫ ♪

PL/I

This program sounds the bell as well as displaying "gong" an appropriate number of times. It operates on local time. <lang PL/I> nautical: procedure options (main); /* 29 October 2013 */ 

  declare (hour, t, i) fixed binary;

  do until (substr(time(), 3, 4) = '0000'); delay (1000); end;
  hour = substr(time(), 1, 2);

  do while ('1'b);
     do i = 1 to hour;
        put edit ('07'X) (a); put skip edit ('gong ') (a); delay (500);
     end;
     t = substr(time(), 5);
     delay (60*60*1000 - t);
  end;

end nautical; </lang>

Python

As well as typing output to stdout, this program plays a sound for each bell as the ␇ characters are printed (The spaces between the ␇ characters are mirrored as varying delays between each ring). <lang python>import time, calendar, sched, winsound

duration = 750 # Bell duration in ms freq = 1280 # Bell frequency in hertz bellchar = "\u2407" watches = 'Middle,Morning,Forenoon,Afternoon,First/Last dog,First'.split(',')

def gap(n=1): 

   time.sleep(n * duration / 1000)

off = gap

def on(n=1): 

   winsound.Beep(freq, n * duration)

def bong(): 

   on(); off(0.5)

def bongs(m): 

   for i in range(m):
       print(bellchar, end=' ')
       bong()
       if i % 2:
           print('  ', end=)
           off(0.5)
   print()

scheds = sched.scheduler(time.time, time.sleep)

def ships_bell(now=None): 

   def adjust_to_half_hour(atime):
       atime[4] = (atime[4] // 30) * 30
       atime[5] = 0
       return atime

   debug = now is not None
   rightnow = time.gmtime()
   if not debug:
       now = adjust_to_half_hour( list(rightnow) )
   then = now[::]
   then[4] += 30
   hr, mn = now[3:5]
   watch, b = divmod(int(2 * hr + mn // 30 - 1), 8)
   b += 1
   bells = '%i bell%s' % (b, 's' if b > 1 else ' ')
   if debug:
       print("%02i:%02i, %-20s %s" % (now[3], now[4], watches[watch] + ' watch', bells), end=' ')
   else:
       print("%02i:%02i, %-20s %s" % (rightnow[3], rightnow[4], watches[watch] + ' watch', bells), end=' ')
   bongs(b)
   if not debug:
       scheds.enterabs(calendar.timegm(then), 0, ships_bell)
       #print(time.struct_time(then))
       scheds.run()

def dbg_tester(): 

   for h in range(24):
       for m in (0, 30):
           if (h,m) == (24,30): break
           ships_bell( [2013, 3, 2, h, m, 15, 5, 61, 0] )

if __name__ == '__main__': 

   ships_bell()</lang>
Output:
00:00, First watch          8 bells ␇ ␇   ␇ ␇   ␇ ␇   ␇ ␇   
00:30, Middle watch         1 bell  ␇ 
01:00, Middle watch         2 bells ␇ ␇   
01:30, Middle watch         3 bells ␇ ␇   ␇ 
02:00, Middle watch         4 bells ␇ ␇   ␇ ␇   
02:30, Middle watch         5 bells ␇ ␇   ␇ ␇   ␇ 
03:00, Middle watch         6 bells ␇ ␇   ␇ ␇   ␇ ␇   
03:30, Middle watch         7 bells ␇ ␇   ␇ ␇   ␇ ␇   ␇ 
04:00, Middle watch         8 bells ␇ ␇   ␇ ␇   ␇ ␇   ␇ ␇   
04:30, Morning watch        1 bell  ␇ 
05:00, Morning watch        2 bells ␇ ␇   
05:30, Morning watch        3 bells ␇ ␇   ␇ 
06:00, Morning watch        4 bells ␇ ␇   ␇ ␇   
06:30, Morning watch        5 bells ␇ ␇   ␇ ␇   ␇ 
07:00, Morning watch        6 bells ␇ ␇   ␇ ␇   ␇ ␇   
07:30, Morning watch        7 bells ␇ ␇   ␇ ␇   ␇ ␇   ␇ 
08:00, Morning watch        8 bells ␇ ␇   ␇ ␇   ␇ ␇   ␇ ␇   
08:30, Forenoon watch       1 bell  ␇ 
09:00, Forenoon watch       2 bells ␇ ␇   
09:30, Forenoon watch       3 bells ␇ ␇   ␇ 
10:00, Forenoon watch       4 bells ␇ ␇   ␇ ␇   
10:30, Forenoon watch       5 bells ␇ ␇   ␇ ␇   ␇ 
11:00, Forenoon watch       6 bells ␇ ␇   ␇ ␇   ␇ ␇   
11:30, Forenoon watch       7 bells ␇ ␇   ␇ ␇   ␇ ␇   ␇ 
12:00, Forenoon watch       8 bells ␇ ␇   ␇ ␇   ␇ ␇   ␇ ␇   
12:30, Afternoon watch      1 bell  ␇ 
13:00, Afternoon watch      2 bells ␇ ␇   
13:30, Afternoon watch      3 bells ␇ ␇   ␇ 
14:00, Afternoon watch      4 bells ␇ ␇   ␇ ␇   
14:30, Afternoon watch      5 bells ␇ ␇   ␇ ␇   ␇ 
15:00, Afternoon watch      6 bells ␇ ␇   ␇ ␇   ␇ ␇   
15:30, Afternoon watch      7 bells ␇ ␇   ␇ ␇   ␇ ␇   ␇ 
16:00, Afternoon watch      8 bells ␇ ␇   ␇ ␇   ␇ ␇   ␇ ␇   
16:30, First/Last dog watch 1 bell  ␇ 
17:00, First/Last dog watch 2 bells ␇ ␇   
17:30, First/Last dog watch 3 bells ␇ ␇   ␇ 
18:00, First/Last dog watch 4 bells ␇ ␇   ␇ ␇   
18:30, First/Last dog watch 5 bells ␇ ␇   ␇ ␇   ␇ 
19:00, First/Last dog watch 6 bells ␇ ␇   ␇ ␇   ␇ ␇   
19:30, First/Last dog watch 7 bells ␇ ␇   ␇ ␇   ␇ ␇   ␇ 
20:00, First/Last dog watch 8 bells ␇ ␇   ␇ ␇   ␇ ␇   ␇ ␇   
20:30, First watch          1 bell  ␇ 
21:00, First watch          2 bells ␇ ␇   
21:30, First watch          3 bells ␇ ␇   ␇ 
22:00, First watch          4 bells ␇ ␇   ␇ ␇   
22:30, First watch          5 bells ␇ ␇   ␇ ␇   ␇ 
23:00, First watch          6 bells ␇ ␇   ␇ ␇   ␇ ␇   
23:30, First watch          7 bells ␇ ␇   ␇ ␇   ␇ ␇   ␇

Racket

This solution uses local time. It also doesn't poll. If it's printing to a terminal that displays \a by playing the system bell, it will play the system bell.

<lang racket>#lang racket

(require racket/date)

(define HALF-HOUR-SECS (* 60 30))

given a date, return the seconds corresponding to the beginning
of that day (in local time)

(define (beginning-of-date d) 

 (find-seconds 0 0 0 (date-day d) (date-month d) (date-year d)))
the seconds at the beginning of today

(define today-secs 

 (beginning-of-date
   (seconds->date (current-seconds))))
hours -> watch
given an hour, return the watch name

(define (hours->watch hours) 

 (cond [(= 0 hours) "first"]
       [(< 0 hours 4.5) "middle"]
       [(< 4 hours 8.5) "morning"]
       [(< 8 hours 12.5) "forenoon"]
       [(< 12 hours 16.5) "afternoon"]
       [(< 16 hours 20.5) "dog"]
       [(< 20 hours 24.5) "first"]))
wait until current-seconds is the given number

(define (wait-til secs) 

 (sleep (- secs (current-seconds))))
display the appropriate message

(define (format-and-print hours bells) 

 (define int-hours (floor hours))
 (define minutes (cond [(integer? hours) "00"]
                       [else "30"]))
 (display
  (~a 
   (~a (floor hours) #:min-width 2 #:pad-string "0" 
       #:align 'right)
   ":" minutes ", " bells " bell(s) of the "
   (hours->watch hours) " watch "))
 ;; play the bells, if possible:
 (for ([i bells])
   (display "\a♪")
   (flush-output)
   (cond [(even? i) (sleep 0.5)]
         [(odd? i) (display " ") (sleep 1)]))
 (display "\n"))
start the loop

(for ([s (in-range today-secs +inf.0 HALF-HOUR-SECS)] 

     [bells (sequence-tail (in-cycle (in-range 8)) 7)]
     [hours (in-cycle (in-range 0 24 1/2))])
 ;; ignore the ones that have already happened:
 (when (< (current-seconds) s)
   (wait-til s)
   (format-and-print hours (add1 bells))))

</lang>

This might produce the following output: 

21:00, 2 bell(s) of the first watch �♪�♪ 
21:30, 3 bell(s) of the first watch �♪�♪ �♪
22:00, 4 bell(s) of the first watch �♪�♪ �♪�♪ 
22:30, 5 bell(s) of the first watch �♪�♪ �♪�♪ �♪
23:00, 6 bell(s) of the first watch �♪�♪ �♪�♪ �♪�♪ 
23:30, 7 bell(s) of the first watch �♪�♪ �♪�♪ �♪�♪ �♪
00:00, 8 bell(s) of the first watch �♪�♪ �♪�♪ �♪�♪ �♪�♪ 
00:30, 1 bell(s) of the middle watch �♪
01:00, 2 bell(s) of the middle watch �♪�♪


REXX

The local time is used instead of Greenwich mean time.

If any arguments are specified, that text is used as a prefix to the times shown (once a minute). Also, the number of bells sounded are shown (if any arguments are specified). If no arguments are specified, no times are shown. In all cases, the PC speaker is used to sound the bells (albeit a poorly sounded bell).

This REXX program makes use of DELAY BIF, which delays (sleeps) for a specified amount of seconds (some REXXes doen't have a DELAY BIF, so one is included here), and SOUND BIF, which produces sounds via the PC speaker (some REXXes doen't have a SOUND BIF, so one is included here). <lang rexx>/*REXX pgm sounds "bells" (using PC speaker) when running (perpetually).*/ echo= arg()\==0 /*echo time & bells if any args. */ signal on halt /*allow a clean way to stop prog.*/ t.1 = '00:30 01:00 01:30 02:00 02:30 03:00 03:30 04:00' t.2 = '04:30 05:00 05:30 06:00 06:30 07:00 07:30 08:00' t.3 = '08:30 09:00 09:30 10:00 10:30 11:00 11:30 12:00' 

      do forever;  t=time();  ss=right(t,2);  mn=right(t,2)    /*times.*/
      ct=time('C')                              /*[↓] add leading zero.*/
      hhmmc=left( right( ct, 7, 0),  5)         /*HH:MM (leading zero).*/
      if echo  then say center(arg(1) ct, 79)   /*echo arg1 with time ?*/
      if ss\==00 & mn\==00 & mn\==30 then       /*wait for next min ?  */
        do;  call delay 60-ss;  iterate;  end   /*delay fraction of min*/

                                                /*[↓]  # bells to peel.*/
        do j=1 for 3  until $\==0;  $=wordpos(hhmmc,t.j);  end /*j*/

      if $\==0 & echo  then say center($ "bells", 79)    /*echo bells? */

        do k=1 for $; call sound 650,1; call delay 1+(k//2==0); end /*k*/
                                                /*[↑]   peel and pause.*/
      call delay 60                             /*ensure don't re-peel.*/
      end   /*forever*/

halt: /*stick a fork in it, we're done.*/</lang> output when using the input of: the time is: 

                             the time is:   1:48pm
                             the time is:   1:49pm
                             the time is:   1:50pm
                             the time is:   1:51pm
                             the time is:   1:52pm
                             the time is:   1:53pm
                             the time is:   1:54pm
                             the time is:   1:55pm
                             the time is:   1:56pm
                             the time is:   1:57pm
                             the time is:   1:58pm
                             the time is:   1:59pm
                             the time is:   2:00pm
                                    4 bells
                             the time is:   2:01pm
                             the time is:   2:02pm
 ∙
 ∙
 ∙

Tcl

This code was originally based on the Perl 6 version, but with numerous adaptations, alterations and (some) corrections. <lang tcl># More sophisticated versions are possible, such as playing a bell sample

  1. using the Snack library.

proc ringTheBell {} { 

   puts -nonewline "\a"

}

  1. The code to convert the (parsed) time into rings of the ship's bell and
  2. printing of the name of the bell.

proc strikeBell {hour minute} { 

   global suppressNormalOutput
   set watches {

Middle Middle Morning Morning Forenoon Forenoon Afternoon Afternoon {First dog} {Last dog} First First 

   }
   set cardinals {one two three four five six seven eight}
   set bells [expr {(($hour % 4) * 2 + $minute / 30)}]
   if {!$bells} {set bells 8}
   puts -nonewline [format "%02d:%02d %9s watch, %6s bell%s gone: \t" \

$hour $minute [lindex $watches [expr { ($hour/2 - ($minute==0 && $hour%2==0)) % 12 }]] [lindex $cardinals [expr {$bells - 1}]] \ [expr {$bells == 1 ? "" : "s"}]] 

   # Set up the ringing of the bells to be done asynchronously
   set t 0
   set suppressNormalOutput 1
   for {set i 0} {$i < $bells-1} {incr i 2} {

after $t { ringTheBell puts -nonewline "\u266b " } incr t 250 after $t { ringTheBell } incr t 750 

   }
   if {$bells % 2} {

after $t { ringTheBell puts -nonewline "\u266a\n" set suppressNormalOutput 0 } 

   } else {

after $t { puts "" set suppressNormalOutput 0 } 

   }

}

  1. Main handler; designed to be called every second, which is plenty.

proc nauticalBell {} { 

   global last suppressNormalOutput
   scan [clock format [clock seconds] -format "%H:%M" -gmt 1] "%d:%d" h m
   if {$last != $m} {

set last $m if {$m%30 == 0} { strikeBell $h $m } elseif {!$suppressNormalOutput} { puts -nonewline [format "%02d:%02d\r" $h $m] } 

   }

}

  1. Set things up, using Tcl's event loop to do the processing

proc every {delay script} { 

   after $delay [list every $delay $script]
   uplevel #0 $script

} set last "" set suppressNormalOutput 0 fconfigure stdout -buffering none every 1000 nauticalBell vwait forever; # Only needed if not running an event loop otherwise</lang>

Sample output:
⋮
08:00   Morning watch,  Eight Bells Gone: 	♫ ♫ ♫ ♫ 
⋮
18:00 First dog watch,   Four Bells Gone: 	♫ ♫ 
18:30  Last dog watch,   Five Bells Gone: 	♫ ♫ ♪
⋮
Retrieved from "https://rosettacode.org/wiki/Nautical_bell?oldid=226431"