tasks a-s

Task/Nautical-bell/0DESCRIPTION

@@ -0,0 +1,4 @@
+The task is to write a small program that emulates a [[wp:Ship's bell#Timing_of_duty_periods|nautical bell]] producing a ringing bell pattern at certain times throughout the day.
+The bell timing should be in accordance with [[wp:GMT|Greenwich Mean Time]], unless locale dictates otherwise.
+
+It is permissible for the program to [[Run as a daemon or service|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.

Task/Nautical-bell/1META.yaml

@@ -0,0 +1,3 @@
+---
+category:
+- Date and time

Task/Nautical-bell/D/nautical-bell.d

@@ -0,0 +1,50 @@
+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);
+    }
+}

Task/Nautical-bell/Perl-6/nautical-bell.pl6

@@ -0,0 +1,41 @@
+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";
+    }
+}

Task/Nautical-bell/Python/nautical-bell.py

@@ -0,0 +1,63 @@
+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()

Task/Nautical-bell/REXX/nautical-bell.rexx

@@ -0,0 +1,24 @@
+/*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.*/

Task/Nautical-bell/Tcl/nautical-bell.tcl

@@ -0,0 +1,75 @@
+# More sophisticated versions are possible, such as playing a bell sample
+# using the Snack library.
+proc ringTheBell {} {
+    puts -nonewline "\a"
+}
+
+# The code to convert the (parsed) time into rings of the ship's bell and
+# 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
+	}
+    }
+}
+
+# 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]
+	}
+    }
+}
+
+# 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