Metronome: Difference between revisions

If the language has no facility to output sound, then it is permissible for this to implemented using just the visual indicator.

<br><br>

 

=={{header|Ada}}==

{{This metronome only does 60 bpm with 1 Measure length.}}

with Ada.Text_IO; use Ada.Text_IO;

 

end loop;

 

 

=={{header|AppleScript}}==

set pauseBetweenBeeps to (60 / bpm)

repeat

beep

delay pauseBetweenBeeps

 

 

=={{header|AutoHotkey}}==

Rather basic implementation, but meets the requirements and is reasonably accurate.

pattern = 4/4 ;

duration = 100 ; Milliseconds

Esc::

MsgBox % "Metronome beeped " beats " beats, over " (A_TickCount-Start)/1000 " seconds. "

 

=={{header|AWK}}==

# syntax: GAWK -f METRONOME.AWK

@load "time"

}

}

{{out}}

<pre>

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

Tempo% = 100

WAIT 6000/Tempo%

NEXT

 

=={{header|C}}==

Using <code>usleep</code> with self correcting delays. Audio is the bell character, which will definitely drive one insane (but I'm ok: my computer doesn't have the bell device). Invoke with <code>./a.out [beats_per_minute]</code>, default to 60.

#include <stdlib.h>

#include <unistd.h>

 

return 0;

 

=={{header|Common Lisp}}==

Depends on quicklisp and OpenAL.

 

(defparameter *short-max* (- (expt 2 15) 1))

(h (play-it high-buffer)))

(princ symbol))

<pre>CL-USER> (metronome 100 '(h l l l))

HLLL

HLL; Evaluation aborted on NIL.</pre>

 

=={{header|EchoLisp}}==

;; available preloaded sounds are : ok, ko, tick, tack, woosh, beep, digit .

(lib 'timer)

(at-every 1000 'metronome) ;; every 1000 msec

;; CTRL-C to stop

 

=={{header|F Sharp|F#}}==

open System.Threading

// You can use .wav files for your clicks.

Seq.initInfinite (fun i -> i + 1)

|> Seq.iter (fun _ -> tempo |> play beats 1 |> ignore)

Sample run:

<pre>$ metronome 120 6

 

=={{header|Factor}}==

command-line continuations io kernel math math.parser namespaces

openal.example sequences system timers ui ui.gadgets

[ [ metronome-cmdline metronome-ui ] [ drop metronome-usage 1 exit ] recover ] with-ui ;

 

 

=={{header|Go}}==

It would be reasonably simple (but covered better in other tasks)

to change bpm and bpb into command line arguments,

So, as long as the output or sound production finishes before the next tick,

the timing will be reliable and will not drift which is the gist of this task.

 

import (

}

}

{{out}}

<pre>

{{works with|GHC|7.4.2}}

 

import Control.Concurrent.MVar

import System.Process (runCommand)

_ <- forkIO $ tick b i

_ <- getChar

 

=={{header|J}}==

MET returns the total number of measures, beats, and elapsed time.<br>

If you leave out the left arguments, it will set them to infinity, so you can go insane without worrying about the metronome ever stopping.

MET=: _ _&$: :(4 : 0)

 

'`print delay'=: 1!:2&4`(6!:3)

met=: _&$: :((] ({:@] [ LF print@[ (-.@{.@] [ delay@[ print@] (BEL,2#BS) , (2 2$'\ /') {~ {.@])^:({:@])) 1 , <.@%) 60&% [ print@('\ '"_))

{{out}}

<pre>

 

=={{header|Java}}==

class Metronome{

double bpm;

}

}

 

=={{header|Julia}}==

{{works with|Julia|0.6}}

 

s = 60.0 / bpm

counter = 0

sleep(s)

end

 

=={{header|Kotlin}}==

 

fun metronome(bpm: Int, bpb: Int, maxBeats: Int = Int.MAX_VALUE) {

}

 

 

{{out}}

=={{header|Liberty BASIC}}==

Requires two supplied wav files for accentuated & standard sounds.

WindowHeight =220

 

#w "flush"

 

 

=={{header|Perl}}==

The module <code>Time::HiRes</code> provides sub-second <tt>sleep</tt>. Text output only.

 

local $| = 1; # autoflush

}

sleep($next_time - gettimeofday());

Sample run

{{out}}

^C

</pre>

 

 

 

 

=={{header|PicoLisp}}==

A short beep (440 Hz, 40 msec) is produced in a child process, while a "pendulum" is swinging left and right. Hitting any key will stop it.

(if (fork)

(let Pid @

(T (key (*/ 30000 Bpm)) (tell Pid 'bye)) )

(prinl) )

Test:

/

 

=={{header|Pure Data}}==

</ul>

[[file:MetronomeScreenShot.png|PureBasic output|thumb|200px]]

msPerBeat.i

BeatsPerMinute.i

Data.q $787A7A7976757678,$415380817C777576,$2C31000002005255,$30202C36202C3020

eClick:

 

=={{header|Python}}==

#lang Python

import time

main()

 

 

=={{header|Racket}}==

#lang racket

 

(send* f (center) (show #t))

(void (thread flip))

 

=={{header|Raku}}==

(formerly Perl 6)

This code only uses textual output, but any noise-generating commands may be substituted; as long as they are executed synchronously, and do not run longer than the specified duration, the timing loop will compensate, since the sequence operator is determining a list of absolute times for each <tt>sleep</tt> to target.

my $duration = 60 / $beats-per-minute;

my $base-time = now + $duration;

sleep $next-time - now;

}

Sample run:

<pre>$ metronome 120 6

 

=={{header|REXX}}==

===textual visual, no sound===

parse arg bpm bpb dur . /*obtain optional arguments from the CL*/

if bpm=='' | bpm=="," then bpm=72 /*the number of beats per minute. */

end /*until e≥es*/

end /*until et≥dur*/

'''output''' &nbsp; when using the default inputs:

<per>

===with sound, REGINA only===

This REXX version &nbsp; ''only'' &nbsp; executes when using the Regina REXX interpreter.

parse arg bpm bpb dur tockf tockd tickf tickd . /*obtain optional arguments from the CL*/

if bpm=='' | bpm=="," then bpm= 72 /*the number of beats per minute. */

end /*until e≥es*/

end /*until et≥dur*/

 

===with sound, PC/REXX only===

parse arg bpm bpb dur tockf tockd tickf tickd . /*obtain optional arguments from the CL*/

if bpm=='' | bpm=="," then bpm= 72 /*the number of beats per minute. */

end /*until e≥es*/

end /*until et≥dur*/

 

=={{header|Ruby}}==

This code rings the audible bell on every beat and write "And n" to stdout where n is the bar number that was just finished

#!/usr/bin/ruby

 

sleep(60.0/bpm)

end

 

=={{header|Scala}}==

val delay = 60000L / bpm

var beats = 0

}

 

{{Out}} See it running in your browser by [https://scastie.scala-lang.org/7iejBcWqQISAIGtBCG6BNQ Scastie (JVM)].

 

=={{header|Sidef}}==

 

var counter = 0

}

 

{{out}}

<pre>

=={{header|Tcl}}==

This code only rings the bell on the high beat, which occurs at the start of the bar.

 

lassign $argv bpm bpb

# Run the metronome until the user uses Ctrl+C...

beat

It might be executed like this:

 

{{omit from|GUISS}}