ForHosting KIT · Maison, cuisine et loisirs

Calculateur de subdivision métronome

À 120 BPM, un temps dure 500 ms et chaque double croche 125 ms, soit 8 clics par seconde. Indiquez un tempo et un découpage du temps, croches, triolets ou doubles croches, pour régler votre travail ou un écho. Gratuit dans votre navigateur.

Gratuit
Fonctionne dans votre navigateur
Sans inscription
Vos données restent sur votre appareil

Lancer gratuitement Voir l’API

Utilisez-le depuis WebAPIE-mailTelegramApp bientôt

Exemple résolu

Si vous saisissez

Tempo: 120
Subdivision: 4

Vous obtenez

Tempo (bpm): 120
Subdivision: 4
Libellé de la subdivision: sixteenth
Temps (ms): 500

Cette capacité répond aux deux questions par une arithmétique transparente — sans moteur audio, sans buffer d'échantillons et sans feeling de swing caché. Le service renvoie la durée du temps en ms, la durée de la subdivision en ms, la fréquence de clic en hertz et un libellé normalisé.

Du tempo à la durée de chaque clic

Le tempo se compte en temps par minute. À 120 BPM, le métronome bat cent vingt noires en une minute, et chaque temps dure donc 500 ms. Une subdivision consiste à couper ce temps en parts égales : deux pour des croches, trois pour des triolets, quatre pour des doubles croches. Pour connaître la durée d’un clic, il suffit de diviser la durée du temps par ce nombre de parts. Avec des doubles croches à 120 BPM, chaque clic dure 125 ms. La fréquence indique combien de clics tombent en une seconde : c’est l’inverse de la durée, ici 8 clics par seconde.

Quand s’en servir et les erreurs à éviter

Ces valeurs servent à régler un métronome qui marque les subdivisions, à travailler un passage rapide en gardant chaque note égale, ou à caler un écho sur le morceau. L’erreur la plus fréquente consiste à confondre le temps et sa division : un tempo de 120 BPM ne signifie pas cent vingt doubles croches par minute. Autre piège, le swing : le calcul suppose des parts strictement égales et ne reproduit aucune sensation décalée. Enfin, le résultat est une durée, pas un son ; il vous reste à l’entrer dans votre métronome ou votre logiciel de musique.

Le tempo et ses subdivisions en millisecondes

Le tempo s'exprime en battements par minute : cent vingt BPM signifie cent vingt pulsations de noire toutes les soixante secondes, donc chaque temps dure soixante mille divisé par cent vingt, soit cinq cents millisecondes. Une subdivision est le nombre de clics égaux placés à l'intérieur de ce temps. Deux donne des croches (deux parts égales par temps), trois donne des triolets, quatre donne des doubles croches, et ainsi de suite.

La durée de chaque subdivision est donc la durée du temps divisée par ce nombre : à cent vingt BPM en doubles croches, vous obtenez cent vingt-cinq millisecondes par clic. Comme le calcul est une simple division sur deux scalaires, chaque environnement d'exécution renvoie les mêmes valeurs arrondies pour les mêmes entrées, ce qui rend le résultat sûr pour les tests de référence, les tables de firmware d'appareils et les pipelines par lots, sans dérive.

Cas d’usage

Grilles de clic d'applications d'entraînement

Convertissez le BPM de l'utilisateur et la grille choisie (croches, triolets, doubles croches) en intervalles en millisecondes pour la planification Web Audio.

Questions fréquentes

Combien cela coûte-t-il ?

Le même calcul s'exécute gratuitement dans votre navigateur sur cette page.

Pourquoi ma requête a-t-elle été rejetée ?

Le tempo doit être un nombre positif (supérieur à zéro, au plus 1000 BPM). La subdivision doit être un nombre positif ou un nom connu.

Cela génère-t-il de l'audio ?

Non. Cela ne renvoie que des nombres de timing (millisecondes et hertz). Utilisez votre propre échantillon de clic ou oscillateur avec ces valeurs.

Combien dure une double croche à 120 BPM ?

125 millisecondes. À ce tempo, chaque temps dure 500 ms et la double croche le découpe en quatre clics égaux : le métronome joue donc 8 clics par seconde.

Comment calculer la durée d’un temps en millisecondes ?

Divisez une minute, soit soixante mille millisecondes, par le tempo. À 120 BPM, cela donne 500 ms par temps ; divisez ensuite par la subdivision pour obtenir chaque clic.

Outils associés

Pour les développeurs — accès API

Tout sur cette page est disponible par programmation. Cette section s'adresse aux équipes qui veulent l'intégrer à leurs systèmes ; les autres peuvent simplement utiliser l'outil ci-dessus.

Endpoint

POSThttps://api.kit.forhosting.com/hobby/metronome-subdivision

Authentification par jeton Bearer : un seul POST met la tâche en file d’attente, et le résultat vous parvient par webhook ou lien signé.

Appeler depuis votre stack

curl -X POST https://api.kit.forhosting.com/hobby/metronome-subdivision \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"tempo":120,"subdivision":"4"}'

const res = await fetch("https://api.kit.forhosting.com/hobby/metronome-subdivision", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "tempo": 120,
    "subdivision": "4"
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/hobby/metronome-subdivision",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "tempo": 120,
    "subdivision": "4"
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/hobby/metronome-subdivision", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"tempo":120,"subdivision":"4"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"tempo":120,"subdivision":"4"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/hobby/metronome-subdivision", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Exemple de requête

{
  "tempo": 120,
  "subdivision": "4"
}

Exemple de réponse

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "hobby.metronome_subdivision",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

L’API est asynchrone : chaque appel renvoie un task_id immédiatement, puis vous interrogez l’état à raison d’une requête par seconde.

Tarifs

par requête$0.002

Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.

Erreurs

HTTP	Code	Signification
`401`	`unauthorized`	Clé API absente ou invalide : vérifiez l’en-tête Authorization.
`402`	`insufficient_balance`	Solde insuffisant : rechargez votre compte pour lancer cette tâche.
`404`	`unknown_type`	Type de tâche inconnu : vérifiez le champ type de votre requête.
`429`	`rate_limited`	Trop de requêtes : ralentissez la cadence, puis réessayez.

Notes techniques

Musiciens, utilisateurs de STAN et concepteurs d'outils de travail ont sans cesse besoin de la même conversion : à ce tempo, combien de millisecondes dure une croche, et combien de clics de subdivision par seconde le métronome doit-il émettre ? Vous transmettez un tempo positif en battements par minute et une subdivision (un nombre positif de notes par temps comme 2, 3 ou 4, ou un nom tel que eighth, triplet ou sixteenth).

Ce que tempo et subdivision signifient en millisecondes

La fréquence en hertz est l'inverse en secondes : mille divisé par la durée en millisecondes, ce qui se simplifie en tempo multiplié par subdivision sur soixante. Ces deux nombres — duration_ms et frequency_hz — sont ce dont ont besoin séquenceurs, métronomes à LED, applications d'entraînement et convertisseurs d'horloge MIDI pour planifier des événements ou piloter une piste de clic.

Comment appeler l'API et lire la réponse

Les formes abrégées comme 8th et 16th fonctionnent aussi. Il n'y a ni saut réseau, ni appel de modèle, ni aléa, si bien que la latence reste dans la bande de l'analyse pure en périphérie. Envoyez deux champs requis : tempo, un nombre positif en BPM (les alias tempo_bpm, bpm et beats_per_minute sont acceptés), et subdivision, un nombre positif de notes par temps ou un nom courant tel que quarter, eighth, sixteenth, triplet, sextuplet ou thirtysecond. Un tempo non positif échoue immédiatement par invalid_input mentionnant tempo et n'est pas facturé ; une subdivision manquante ou impossible à analyser déclenche de même invalid_input avec un nom de champ clair. Une réponse réussie renvoie tempo_bpm, la subdivision numérique utilisée, un subdivision_label d'affichage, beat_ms, duration_ms, frequency_hz, et les libellés d'unité pour la durée et la fréquence. Les valeurs sont arrondies à six décimales pour que le JSON reste identique d'un isolat et d'un navigateur à l'autre. Associez la durée à la fréquence d'échantillonnage de votre moteur audio si vous avez besoin de décalages d'échantillons, ou injectez frequency_hz dans un oscillateur ou un pilote de clignotement LED.

Où cela s'insère dans les flux musicaux et produit

Les équipes d'applications d'entraînement recueillent le BPM cible et la grille préférée de l'utilisateur et ont besoin d'intervalles de clic exacts avant de planifier des rappels Web Audio ou Core Audio. Les pédagogues de la musique construisent des outils de classe qui montrent aux élèves pourquoi un triolet à quatre-vingt-dix BPM ne ressent pas comme des croches droites. Le parcours navigateur est gratuit pour des vérifications isolées : saisissez cent vingt BPM et quatre (doubles croches) et confirmez cent vingt-cinq ms et huit hertz. Les auteurs de plugins de STAN convertissent le tempo hôte et un menu de subdivision en prises de ligne à retard ou en pas d'arpégiateur sans réimplémenter des divisions sensibles aux flottants qui divergent sur l'arrondi. Le firmware d'un métronome matériel peut précalculer des tables hors ligne à partir de la même formule et les revérifier avec un JSON de référence. Les développeurs de jeux et d'installations interactives synchronisent jeux de lumière ou impulsions haptiques sur des grilles musicales en utilisant frequency_hz comme horloge. Le parcours d'API coûte $0.002 par requête réussie et est facturé à l'unité, ce qui garde bon marché les générateurs de presets en masse et les scripts d'accueil mobile tout en couvrant l'exécution en périphérie. Comme les résultats sont déterministes, les journaux d'audit peuvent stocker la réponse complète et la rejouer des années plus tard sans dérive, et les suites de régression figent le JSON attendu exact pour chaque nom pris en charge et chaque subdivision numérique.

Cas d'intégration

Tables de timing pour STAN et plugins

Mappez le tempo hôte plus un contrôle de subdivision vers des prises de retard, des pas d'arpégiateur ou des cadences de clignotement LED avec un JSON stable.

Démonstrations de pédagogie musicale

Montrez aux élèves comment durée du temps et subdivision interagissent en renvoyant duration_ms et frequency_hz pour une comparaison côte à côte.

Questions techniques

Comment duration_ms est-il calculé ?

beat_ms = 60000 / tempo_bpm, puis duration_ms = beat_ms / subdivision (notes par temps). La fréquence vaut tempo × subdivision / 60 hertz.

Quelles valeurs de subdivision sont acceptées ?

Tout nombre positif de notes par temps, ou des noms tels que quarter, eighth, sixteenth, triplet, sextuplet et thirtysecond (plus des alias courants comme 8th et 16th).

Consulter la documentation complète du KIT →

Lancer gratuitement