De alguma forma, é um acompanhamento dessa pergunta:

Como posso detectar o BPM (batimentos por minuto) de uma música?

Mas agora, em vez de detectá-los nas músicas, quero gerá-los.

Estou procurando um aplicativo que produza um som (algo curto como um sinal sonoro) um número configurável de vezes por minuto.

Se eu disser 20bpm, ele emitirá esse som a cada 3 segundos. (60/20)
Se 60bpm, a cada segundo.
Se 120bpm a cada meio segundo.

A razão para isso é que estou aprendendo a tocar bateria e o bpm parece realmente importante. Estou acompanhando este vídeo no youtube .

atualizar

Parece que eles são chamados metronomese até o Google tem um. Coisas legais.
https://www.google.com/search?q=metronomes
Obrigado Nick.

Como mencionado em um comentário, não consegui que os metrônomos mencionados (existentes para Linux / Ubuntu) funcionassem no 16.04, pelo menos não fora da caixa. Não gastei muito tempo em fazê-lo funcionar , pois praticamente todos dão a impressão de serem abandonados.

Hora de escrever uma ...

Essa resposta ( trabalho em andamento ) deve levar a um metrônomo, incluindo a GUI. Um bom momento para mencionar possíveis recursos que você deseja.

1. Metrônomo CLI

Criar um metrônomo direto acaba sendo surpreendentemente simples:

#!/usr/bin/env python3
import subprocess
import sys
import time

bpm = int(sys.argv[1])
pauze = 60/bpm

while True:
    time.sleep(pauze)
    subprocess.Popen(["ogg123", "/usr/share/sounds/ubuntu/stereo/bell.ogg"])

Como usar

1. O metrônomo precisa de ferramentas vorbis, para tocar o som

   sudo apt-get install vorbis-tools
   

2. Copie o script acima em um arquivo vazio, salve-o como metronome.py

3. Execute-o com o bpm como argumento:

   python3 /path/to/metronome.py <bpm>
   

   por exemplo:

   python3 /path/to/metronome.py 100
   

   Para executá-lo com 100 batimentos por minuto

Nota

Para o som, usei o arquivo /usr/share/sounds/ubuntu/stereo/bell.ogg, que deve estar no seu sistema por padrão (testado em 14.04 / 16.04). No entanto, você pode usar qualquer .oggamostra ( ) que desejar. Na versão final, várias opções (sons) estarão disponíveis.

2. Versão GUI surpreendentemente simples

Como próximo passo, uma versão muito básica, a última versão sem um instalador:

O script

#!/usr/bin/env python3
import gi
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk
import sys
import subprocess
import time
from threading import Thread
import os

path = os.path.dirname(os.path.realpath(__file__))

class MetroWindow(Gtk.Window):
    def __init__(self):
        Gtk.Window.__init__(self, title="Shockingly simple Metronome")
        self.speed = 70
        self.run = False
        # maingrid
        maingrid = Gtk.Grid()
        maingrid.set_column_homogeneous(True)
        maingrid.set_row_homogeneous(False)
        maingrid.set_border_width(30)
        self.add(maingrid)
        # icon
        image = Gtk.Image(xalign=0)
        image.set_from_file(os.path.join(path, "icon.png"))
        maingrid.attach(image, 0, 0, 1, 1)
        # vertical slider,  initial value, min, max, step, page, psize
        self.v_scale = Gtk.Scale(
            orientation=Gtk.Orientation.VERTICAL,
            adjustment=Gtk.Adjustment.new(self.speed, 10, 240, 1, 0, 0)
            )
        self.v_scale.set_vexpand(True)
        self.v_scale.set_digits(0)
        self.v_scale.connect("value-changed", self.scale_moved)
        maingrid.attach(self.v_scale, 1, 0, 2, 1)

        self.togglebutton = Gtk.Button("_Run", use_underline=True)
        self.togglebutton.connect("clicked", self.time_out)
        self.togglebutton.set_size_request(70,20)
        maingrid.attach(self.togglebutton, 3, 3, 1, 1)

        # start the thread
        self.update = Thread(target=self.run_metro, args=[])
        self.update.setDaemon(True)
        self.update.start()

    def scale_moved(self, event):
        self.speed = int(self.v_scale.get_value())

    def time_out(self, *args):
        if self.run == True:
            self.run = False
            self.togglebutton.set_label("Run")
        else:
            self.run = True
            self.togglebutton.set_label("Pauze")

    def pauze(self):
        return 60/self.speed

    def run_metro(self):
        soundfile = "/usr/share/sounds/ubuntu/stereo/bell.ogg"
        while True:
            if self.run == True:
                subprocess.Popen([
                    "ogg123", soundfile
                    ])
            time.sleep(self.pauze())

def run_gui():
    window = MetroWindow()
    window.connect("delete-event", Gtk.main_quit)
    window.set_resizable(False)
    window.show_all()
    Gtk.main()

run_gui()

A imagem

Como usar

1. Como a versão cli, esta precisa vorbis-tools:

   sudo apt-get install vorbis-tools
   

2. Copie o script em um arquivo vazio, salve-o como metro.py

3. Direit clique na imagem acima, salve-o em um e no mesmo diretório que o script (exatamente) como: icon.png.

4. Simplesmente execute o metrônomo pelo comando:

   python3 /path/to/metro.py
   

3. PPA para o metrônomo laranja

Está feito!

O metrônomo está pronto para instalação.
O metrônomo laranja vem com um conjunto de sons diferentes para escolher, e as batidas podem ser agrupadas. Todas as alterações são aplicadas imediatamente no metrônomo em execução:

Para instalar:

sudo apt-add-repository ppa:vlijm/orangemetronome
sudo apt-get update
sudo apt-get install orangemetronome

Trabalho para fazer

• Atualmente, o metrônomo vem com quatro sons diferentes para você escolher. Provavelmente alguns serão adicionados nos próximos dias, alguns deles serão substituídos / atualizados

• A longo prazo,
  a longo prazo, estou pensando em adicionar a opção para estruturas complexas (personalizadas) como 3 + 3 + 2, 2 + 2 + 2 + 3 etc., que eu sempre sentia falta dos metrônomos.

Finalmente

A versão mais recente (atual) 0.5.3adiciona vários sons, mas o mais importante é a opção de executar batidas irregulares (compostas). Nesta versão, eles são codificados. Será personalizável a partir da versão> 1.

Parece que você está procurando um metrônomo!

O software de edição de áudio Audacity pode gerar uma batida ou tom constante, semelhante ao metrônomo (consulte o menu "Gerar"), embora existam programas mais simples que listarei abaixo. O Audacity está nos repositórios de software do Ubuntu e pode ser instalado através do Centro de Software ou digitando sudo apt install audacityem uma janela do terminal.

Metrônomos on-line são abundantes, se você planeja ter acesso à Internet durante sua prática.

Outro software de metrônomo disponível nos repositórios de software do Ubuntu inclui gtick , klick , gtklick e kmetronome , embora eu não tenha experimentado nenhum deles.

Metrônomo simples do Bash

Uso

metronome.sh [beats per minute] [beats per measure]

Info

• Joga a 120 bpm em 4 por padrão
• Mais informações e um script muito mais sofisticado estão disponíveis no meu repositório do GitHub: metronome.sh . O script abaixo está lá emmetronome-core.sh

Por exemplo

metronome.sh
metronome.sh 75     # 75 BPM
metronome.sh 120 3  # 120 BPM, 3 beats per measure

Roteiro

#!/bin/bash
# metronome.sh - Is a metronome.
# Usage: metronome.sh [beats per minute] [beats per measure]

# Set BPM and beats per measure.
bpm="${1-120}"
msr="${2-4}"

# Get seconds per beat using bc.
# "-0.004" accounts for approximate execution time.
beat_time="$(bc -l <<< "scale=5; 60/$bpm-0.004")"

echo "Metronome playing $bpm BPM, $msr beats per measure"
echo -n "Press Ctrl+C to quit."

while true; do
    for ((i=1; i<=$msr; i++)); do
        if [[ $i -eq 1 ]]; then
            # Accentuated beat.
            canberra-gtk-play --id='dialog-information' &
        else
            # Unaccentuated beat
            canberra-gtk-play --id='button-toggle-on' &
        fi
        # Wait before next beat. Will exit if beat time is invalid.
        sleep "$beat_time" || exit
    done
done

toco guitarra e uso gtick , funciona muito bem para mim, posso ajustar as batidas por minuto, volume e até assinaturas de tempo, 1 / 4,2 / 4,3 / 4 e assim por diante. você pode instalá-lo a partir da linha de comando usando:

sudo apt-get install gtick

aqui está o meu truque : i.imgsafe.org/f2dc6c70f2.png

Já experimentou o kmetronome? Deve ser capaz de usar o apt-get / synaptic.