Calculateur de ressorts en parallèle
Trois ressorts en parallèle de 120, 180 et 300 N/m équivalent à un seul ressort de 600 N/m. Saisissez la raideur de chacun et obtenez la valeur combinée ainsi que le nombre de ressorts comptés. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Exemple résolu
- Constantes des ressorts
- 120, 180, 300
- Nombre de ressorts
- 3
- Constante de ressort équivalente
- 600
Le calculateur de ressorts en parallèle détermine la constante équivalente de toute liste non vide de ressorts soumis au même déplacement. Saisissez chaque raideur en N/m, ou employez une autre unité cohérente pour toute la liste, puis le calculateur les additionne afin d’obtenir la raideur combinée. Il indique également le nombre de ressorts pris en compte et conserve les valeurs transmises pour faciliter leur vérification. Le calcul est déterministe, ne dépend d’aucun service externe et refuse une liste vide ou des constantes incorrectes plutôt que de fournir un résultat trompeur.
Principe de combinaison des ressorts en parallèle
Des ressorts sont montés en parallèle lorsque chacun relie les deux mêmes corps mobiles, de sorte qu’ils subissent tous la même extension ou compression. La charge appliquée se répartit entre les ressorts et la force exercée par chacun s’ajoute à la force de rappel totale. Puisque la loi de Hooke exprime la force comme le produit de la raideur par le déplacement, additionner ces forces pour un déplacement commun revient à additionner directement les raideurs.
Ce calculateur applique précisément cette relation à la liste fournie. Par exemple, trois ressorts parallèles de 120, 180 et 300 N/m donnent une raideur combinée de 600 N/m. L’ensemble est plus raide que chacun de ses éléments, car tous s’opposent simultanément au mouvement.
Cette règle ne vaut que pour un véritable montage parallèle ; des ressorts reliés bout à bout suivent la relation en série et ne doivent pas être évalués avec cet outil.
Saisie des valeurs et lecture du résultat
Indiquez une constante pour chaque ressort actif de l’assemblage parallèle. Toutes les valeurs doivent être exprimées dans la même unité avant leur addition. Si chaque entrée est en newtons par mètre, la constante équivalente sera elle aussi en newtons par mètre.
Vous pouvez également employer lbf/in ou une autre unité de raideur, à condition d’utiliser une seule unité dans toute la liste ; un mélange d’unités produit une somme numérique dépourvue de sens physique. Les constantes doivent être des nombres finis et positifs ou nuls. La valeur zéro est admise, car elle peut représenter un élément idéalisé qui n’apporte aucune raideur, mais il convient de contrôler les données réelles lorsqu’elle apparaît.
Elle fournit aussi la formule afin que le résultat reste compréhensible dans un relevé de calcul. Sans aucun ressort, la requête échoue explicitement, car un assemblage vide ne définit pas la combinaison demandée.
Contrôles pratiques pour un modèle fiable
Avant d’exploiter la valeur combinée, vérifiez que la géométrie mécanique impose réellement le même déplacement à chaque ressort. Les tringleries, montages inclinés, dispositifs de précharge et supports souples peuvent introduire des rapports de mouvement ou un comportement non linéaire qu’une simple somme ne décrit pas. Assurez-vous également que chaque constante annoncée est valable dans la plage de fonctionnement prévue.
Le contact entre spires, les limites d’allongement, les enroulements progressifs, les élastomères et les bras de levier variables peuvent rendre la raideur dépendante du déplacement. Pour des ressorts linéaires ordinaires directement montés en parallèle, la somme permet d’estimer la déflexion : divisez la force appliquée par la raideur équivalente en conservant des unités cohérentes de force et de longueur. Elle permet aussi d’évaluer rapidement l’ajout ou le retrait d’un ressort auxiliaire, de comparer plusieurs ensembles ou de contrôler une feuille de calcul.
Les deux voies utilisent le même calcul déterministe sans service externe.
Cas d’usage
Dimensionner un ensemble à charge partagée
Additionnez la raideur nominale de chaque élément parallèle avant d’estimer le déplacement sous la charge totale.
Comparer des configurations de suspension
Mesurez l’effet d’un ressort auxiliaire sur la raideur équivalente d’un montage parallèle direct.
Contrôler des feuilles de calcul techniques
Recalculez une liste de constantes et comparez le total déterministe à une feuille de calcul ou à une note de conception.
Questions fréquentes
Quelles unités faut-il employer ?
Vous pouvez utiliser toute unité de raideur, comme N/m ou lbf/in, mais gardez la même pour chaque valeur. Le résultat conservera cette unité.
Une constante de ressort peut-elle être nulle ?
Oui. Zéro est accepté et n’ajoute aucune raideur, ce qui peut représenter un élément idéalisé inactif. Les valeurs négatives sont refusées.
Ce calculateur traite-t-il les ressorts en série ?
Non. Les ressorts en série obéissent à une relation réciproque ; leurs constantes ne doivent donc pas être saisies comme celles de ressorts parallèles.
Comment additionner des ressorts en parallèle ?
Il suffit d'additionner leurs constantes. Des ressorts de 120, 180 et 300 N/m en parallèle donnent 600 N/m, car tous se déforment de la même quantité et leurs forces s'ajoutent.
Pourquoi l'ensemble est-il plus raide que chaque ressort ?
Tous les ressorts résistent au même mouvement en même temps, leurs forces se cumulent donc. Le résultat dépasse le ressort le plus raide du groupe : 600 N/m contre 300 N/m.
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
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/mech/spring-parallel \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"spring_constants":[120,180,300]}'const res = await fetch("https://api.kit.forhosting.com/mech/spring-parallel", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"spring_constants": [
120,
180,
300
]
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/mech/spring-parallel",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"spring_constants": [
120,
180,
300
]
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/mech/spring-parallel", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"spring_constants":[120,180,300]}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"spring_constants":[120,180,300]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/mech/spring-parallel", 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
{
"spring_constants": [
120,
180,
300
]
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "mech.spring_parallel",
"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
Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.
Limites
max_items | 1000 |
max_spring_constant | 1000000000000 |
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
Principe de combinaison des ressorts en parallèle
Si les constantes individuelles sont k1, k2, puis les suivantes jusqu’à kn, le résultat est k_equivalent = k1 + k2 + ... + kn.
Saisie des valeurs et lecture du résultat
La sortie reprend la liste normalisée, précise le nombre de ressorts et place la valeur combinée dans equivalent_spring_constant.
Contrôles pratiques pour un modèle fiable
Une requête API coûte $0.002, tandis que le calcul peut s’exécuter localement dans le navigateur.
Questions techniques
Quelle est la formule des ressorts en parallèle ?
Additionnez toutes les constantes : k_equivalent = k1 + k2 + ... + kn. Les ressorts doivent subir le même déplacement.
Puis-je envoyer une liste vide ?
Non. Il faut au moins une constante de ressort ; une liste vide renvoie une erreur invalid_input.
Quel est le prix d’un calcul par API ?
Chaque requête API coûte $0.002. Le même calcul est disponible gratuitement dans le navigateur.