ForHosting KIT · Outils pour développeurs

Calculateur de fréquence et de période d’horloge

Une horloge numérique relie fréquence, période et cycles écoulés. Saisissez une fréquence, par exemple 100 MHz, pour connaître la durée d’un cycle, ou une période, telle que 10 ns, pour retrouver la fréquence.

● BetaGratuit · dans votre navigateur

Lancer gratuitement Voir l’API

Utilisez-le depuis WebAPIE-mailTelegramApp bientôt

Vous pouvez aussi indiquer un intervalle afin d’en calculer le nombre de cycles. Les résultats emploient des unités d’ingénierie adaptées aux processeurs, bus, FPGA, microcontrôleurs, instruments de mesure et communications numériques.

Convertissez la fréquence d’horloge en période

La fréquence exprime le nombre de cycles par seconde, tandis que la période indique la durée d’un cycle. Ces grandeurs sont réciproques : la période vaut un divisé par la fréquence. Une horloge de 100 MHz effectue 100 millions de cycles par seconde ; chacun dure donc 10 nanosecondes. Sélectionnez Hz, kHz, MHz ou GHz : le calculateur normalise la valeur et affiche plusieurs échelles de fréquence et de temps. Vous évitez ainsi les erreurs de préfixe métrique. Utilisez la période pour étudier les marges de synchronisation, régler un oscilloscope ou comparer les contraintes d’un périphérique. La fréquence doit être strictement positive, car zéro n’a pas de période finie.

Convertissez une période mesurée en fréquence

Une fiche technique, un chronogramme ou un oscilloscope fournit parfois la durée du cycle plutôt que sa cadence. La fréquence vaut alors un divisé par la période. Saisissez des secondes, millisecondes, microsecondes, nanosecondes ou picosecondes. Ainsi, 20 ns correspondent à 50 MHz. Indiquez soit la fréquence, soit la période, jamais les deux, afin d’éviter toute contradiction. Vérifiez que la mesure couvre un cycle complet : une largeur d’impulsion n’est pas forcément une période lorsque le rapport cyclique diffère de cinquante pour cent, et un bit de protocole peut occuper plusieurs cycles de référence.

Calculez les cycles sur un intervalle

Ajoutez un intervalle pour multiplier la fréquence normalisée par la durée en secondes. Vous pouvez ainsi convertir un délai en ticks de minuterie, estimer le budget d’une routine ou contrôler une simulation. `cycles` peut être fractionnaire si l’intervalle s’achève au milieu d’un cycle ; `complete_cycles` arrondit vers le bas et ne compte que les cycles terminés. Un intervalle nul renvoie zéro. Son unité se choisit indépendamment de celle de l’horloge. Le calcul suppose une horloge idéale et constante ; pour une marge réelle, prenez séparément en compte tolérance, gigue, dérive et éventuelle désactivation d’horloge.

Cas d’usage

Contrôler la temporisation d’un FPGA

Convertissez la cadence cible en nanosecondes disponibles pour chaque étage synchrone.

Configurer un compteur

Déterminez combien de cycles d’entrée tiennent dans un délai en microsecondes ou millisecondes.

Interpréter une mesure

Transformez une période relevée à l’oscilloscope ou à l’analyseur logique en MHz ou GHz.

Questions fréquentes

Combien coûte un calcul par API ?

Chaque requête API coûte $0.002 ; le calculateur fonctionne aussi gratuitement dans le navigateur.

Quelle formule convertit la fréquence en période ?

La période en secondes vaut 1 divisé par la fréquence en hertz.

Puis-je fournir fréquence et période ?

Non. Indiquez exactement une grandeur afin de conserver une seule source sans ambiguïté.

Pourquoi le nombre de cycles peut-il être décimal ?

L’intervalle peut finir en cours de cycle. Utilisez complete_cycles pour ne compter que les cycles achevés.

La gigue ou la tolérance sont-elles incluses ?

Non. Le modèle est idéal et constant ; ajoutez séparément tolérance, gigue, dérive et clock gating.

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/elec/clock-period

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/elec/clock-period \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"frequency":100,"frequency_unit":"MHz"}'

const res = await fetch("https://api.kit.forhosting.com/elec/clock-period", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "frequency": 100,
    "frequency_unit": "MHz"
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/elec/clock-period",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "frequency": 100,
    "frequency_unit": "MHz"
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/elec/clock-period", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"frequency":100,"frequency_unit":"MHz"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"frequency":100,"frequency_unit":"MHz"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/elec/clock-period", 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

{
  "frequency": 100,
  "frequency_unit": "MHz"
}

Exemple de réponse

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "elec.clock_period",
  "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.

Consulter la documentation complète du KIT →