Il s'agit en quelque sorte d'un suivi de cette question:

Comment puis-je détecter le BPM (battements par minute) d'une chanson?

Mais maintenant, au lieu de les détecter dans les chansons, je veux les générer.

Je recherche une application qui produira un son (quelque chose de court comme un bip) un nombre configurable de fois par minute.

Si je dis 20bpm, il émettra ce son toutes les 3 secondes. (60/20)
Si 60 bpm, toutes les secondes.
Si 120 bpm toutes les demi-secondes.

La raison en est que j'apprends à jouer des kits de batterie et le bpm semble vraiment important. Je suis en train de suivre cette vidéo sur youtube .

mise à jour

Semble qu'ils sont appelés metronomeset même Google en a un. Truc cool.
https://www.google.com/search?q=metronomes
Merci Nick.

Comme mentionné dans un commentaire, je n'ai pas pu faire fonctionner les métronomes mentionnés (existants pour Linux / Ubuntu) le 16.04, du moins pas prêts à l'emploi. Je n'ai pas passé beaucoup de temps à le faire fonctionner , car pratiquement tous donnent l'impression d'être abandonnés.

Il est temps d'en écrire un ...

Cette réponse ( travaux en cours ) devrait à terme déboucher sur un métronome, notamment GUI. Un bon moment pour mentionner les fonctionnalités possibles que vous souhaitez.

1. Métronome CLI

La création d'un métronome simple s'avère d'une simplicité choquante:

#!/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"])

Comment utiliser

1. Le métronome a besoin d'outils vorbis pour jouer le son

   sudo apt-get install vorbis-tools
   

2. Copiez le script ci-dessus dans un fichier vide, enregistrez-le sous metronome.py

3. Exécutez-le avec le bpm comme argument:

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

   par exemple:

   python3 /path/to/metronome.py 100
   

   Pour l'exécuter avec 100 battements par minute

Remarque

Pour le son, j'ai utilisé le fichier /usr/share/sounds/ubuntu/stereo/bell.ogg, qui devrait être sur votre système par défaut (testé le 14.04 / 16.04). Vous pouvez cependant utiliser n'importe quel .oggéchantillon ( ) que vous aimez. Dans la version finale, un certain nombre d'options (sons) seront disponibles.

2. Version GUI incroyablement simple

Prochaine étape, une version très basique, la dernière version sans installateur:

Le 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()

L'image

Comment utiliser

1. Comme la version cli, celle-ci a besoin de vorbis-tools:

   sudo apt-get install vorbis-tools
   

2. Copiez le script dans un fichier vide, enregistrez-le sous metro.py

3. Faites un clic droit sur l'image ci - dessus, enregistrez - en un et le même répertoire que le script (exactement) comme: icon.png.

4. Exécutez simplement le métronome par la commande:

   python3 /path/to/metro.py
   

3. PPA pour le métronome orange

C'est fait!

Le métronome est prêt à être installé.
Le Orange Metronome est livré avec un ensemble de sons différents au choix, et les battements peuvent être regroupés. Toutes les modifications sont appliquées immédiatement sur le métronome en cours d'exécution:

À installer:

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

Travail à faire

• Actuellement, le métronome propose quatre sons différents. Quelques-uns seront probablement ajoutés dans les prochains jours, certains seront remplacés / mis à jour

• À plus long terme
  Pour le plus long terme, je pense ajouter l'option pour les structures complexes (personnalisées) comme 3 + 3 + 2, 2 + 2 + 2 + 3 etc., ce que j'ai toujours manqué dans les métronomes existants.

finalement

La dernière version (actuelle) 0.5.3ajoute un certain nombre de sons, mais plus important encore, la possibilité d'exécuter des battements irréguliers (composites). Dans cette version, ils sont codés en dur. Sera personnalisable à partir de la version> 1.

On dirait que vous cherchez un métronome!

Le logiciel d'édition audio Audacity peut générer un rythme ou un ton constant, semblable à un métronome (regardez dans le menu "Générer"), bien qu'il existe des programmes plus simples que je vais énumérer ci-dessous. Audacity se trouve dans les référentiels de logiciels Ubuntu et peut être installé via le Centre logiciel ou en tapant sudo apt install audacitydans une fenêtre de terminal.

Les métronomes en ligne sont nombreux, si vous prévoyez d'avoir accès à Internet pendant votre pratique.

Les autres logiciels de métronome disponibles dans les référentiels de logiciels Ubuntu incluent gtick , klick , gtklick et kmetronome , bien que je n'en ai pas essayé moi-même.

Métronome Bash simple

Usage

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

Info

• Il joue à 120 bpm en 4 par défaut
• Plus d'informations et un script beaucoup plus sophistiqué sont disponibles sur mon dépôt GitHub: metronome.sh . Le script ci-dessous est là sousmetronome-core.sh

Par exemple

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

Scénario

#!/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

je joue de la guitare et j'utilise gtick , cela fonctionne assez bien pour moi, je peux ajuster les battements par minute, le volume et même les signatures temporelles, 1 / 4,2 / 4,3 / 4, etc. vous pouvez l'installer à partir de la ligne de commande en utilisant:

sudo apt-get install gtick

voici mon gtick : i.imgsafe.org/f2dc6c70f2.png

Avez-vous essayé le kmétronome? Devrait être capable d'utiliser apt-get / synaptic.