Metronome: Difference between revisions

{{trans|Python}}

 

V t = 60.0 / bpm

V counter = 0

sleep(t)

 

 

=={{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|Arturo}}==

freq: 60000/bpm

i: 0

beats: to :integer arg\1

 

 

=={{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

{{libheader| System.SysUtils}}

{{Trans|Java}}

program Metronome;

 

begin

StartMetronome(120, 4);

{{out}}

<pre>TOCK

 

=={{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|FreeBASIC}}==

REM La función Sound no es mía, incluyo los créditos correspondientes.

' Sound Function v0.3 For DOS/Linux/Win by yetifoot

Sleep(retardo)

Loop

 

 

=={{header|Go}}==

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|Locomotive Basic}}==

{{trans|Python}}

20 sleep=50*60/bpm

30 counter=0

120 counter=counter+1

130 if counter=bpb then counter=0

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

Shows/plays a visual and auditory metronome:

ss = Sound[Play[Sin[2000 t], {t, 0, 0.05}]];

bpm = 180;

];

Pause[slp];

 

=={{header|Nim}}==

Textual version only.

 

proc metronome(tempo, pattern: Positive) =

sleep(delay)

 

 

=={{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}}

===Graphical version===

Visual only, unless you want to uncomment the bell call.

 

use strict;

-width => 5);

$mw->after( 60_000 / $bpm / 2 => \&tick );

 

=={{header|Phix}}==

 

=={{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}}==

 

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

These REXX program examples are modeled after the Raku example.

===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:

 

=={{header|Wren}}==

{{trans|Kotlin}}

Modified to ring the bell on each beat.

import "io" for Stdout

 

}

 

 

{{out}}

TICK tick tick tick

</pre>

 

{{omit from|GUISS}}