Comment extraire les temps de cycle du G-code en 7 étapes

Extraire les temps de cycle et les temps standards depuis le G-code peut débloquer des gains de productivité mesurables, des devis plus précis et une meilleure planification des effectifs, sans embaucher d’opérateurs supplémentaires. Ce guide présente un processus pratique en sept étapes pour passer d’estimations de temps d’exécution G-code souvent optimistes à des temps standards validés, prêts à être intégrés dans vos systèmes MES/ERP.

En bref

• Données nécessaires : l’extraction de temps de cycle depuis le G-code nécessite la cinématique machine, les outils et le contexte du programme ; l’absence de certains paramètres peut fausser les estimations de 10 à 40 %.
• Méthode de simulation : utiliser la simulation cinématique (accélération, jerk, enchaînement des axes) pour des estimations précises ; la simple sommation distance/vitesse sous-estime les programmes à nombreux petits mouvements.
• Validation et automatisation : valider avec les journaux machine/données TRS et automatiser l’extraction vers le MES via REST, OPC-UA ou CSV pour une planification de capacité fiable et une amélioration continue.

Pourquoi c’est important : temps de cycle, temps standard, takt time et TRS

Avant de détailler les sept étapes, il faut être précis sur ce que l’on calcule et sur le niveau de précision exigé.

• Le temps de cycle est le temps qu’une machine met pour usiner une pièce, de la mise en route à l’arrêt de la broche, ou du début à la fin du programme pour cette opération.
• Le takt time est la cadence dictée par le client (temps de production disponible ÷ quantité demandée). Il sert à rythmer la production et à équilibrer les lignes.
• Le temps standard est le temps de cycle augmenté des activités opérateur documentées et des marges (personnelles, fatigue, aléas inévitables). C’est le chiffre réellement utilisé pour l’ordonnancement et la planification des effectifs.

Ces distinctions comptent, car les trois composantes du TRS en dépendent. La disponibilité compare le temps de marche au temps planifié, la performance compare le cycle réel au cycle standard, et la qualité compare les pièces bonnes aux pièces totales.

Une erreur systématique se cumule vite. Une machine dont le cycle réel est de 120 s, déclaré à 132 s (10 % trop haut), réduit d’environ 10 % le débit théorique calculé et donne l’impression que l’atelier est sous-utilisé. L’erreur inverse crée des plannings surchargés, des retards et des heures supplémentaires.

À plus grande échelle, une sous-estimation de 15 % sur 1 000 heures de production peut générer 150 heures supplémentaires non prévues, des dates d’échéance manquées et un en-cours gonflé. Passer d’une précision de ±10 % à ±3-5 % peut relever l’utilisation effective et augmenter le débit de plusieurs points de pourcentage, sans personnel supplémentaire.

Définir vos objectifs de KPI avant de commencer

Décidez d’emblée ce que les temps calculés vont servir : objectifs de débit horaire, planification de la capacité par poste, bases de performance du TRS ou alignement sur le takt time pour l’assemblage. Cela détermine le degré de prudence de vos marges. L’alignement sur le takt time pour un assemblage multi-modèles exige d’inclure explicitement la manutention opérateur. La planification de capacité au niveau machine peut, elle, utiliser le temps de cycle machine seul avec des marges minimales. Noter l’objectif de KPI à côté de votre analyse G-code rend vos hypothèses vérifiables par la suite.

Pourquoi les temps de cycle CNC sont souvent faux en atelier

Entre les changements d’outil, les interventions opérateurs et les variations de cadence, les écarts entre temps théorique et temps réel peuvent être significatifs, souvent 20 à 50 % de différence. Les temps issus du G-code ou du logiciel FAO ignorent les conditions réelles de fabrication. Les opérateurs ajustent régulièrement les paramètres, corrigent des défauts et gèrent des imprévus, tandis que l’usure des outils et les variations machine surviennent en continu. Ces écarts déstabilisent les flux de production, augmentent l’en-cours et compliquent la gestion des délais.

Comment savoir si vos temps de cycle sont sous-estimés ? Signaux d’alerte

• Les ordres de fabrication dépassent systématiquement la durée planifiée.
• Certaines machines semblent constamment saturées pendant que d’autres restent sous-utilisées.
• L’en-cours de production augmente.
• Les équipes passent plus de temps à réajuster le planning qu’à piloter la production.

La solution : mettre en place un suivi de production basé sur des temps réels, validés, ce que ce guide détaille étape par étape ci-dessous.

Étape 1 : quelles données et fichiers « pré-vol » sont nécessaires pour extraire les temps de cycle depuis le G-code ?

La précision de l’extraction dépend de bien plus que le seul texte du G-code. Les éléments essentiels à réunir avant de commencer :

Fichier G-code et informations d’en-tête : Le programme CNC brut, incluant les lignes d’état modal, les blocs de début/fin, et tous les sous-programmes ou appels de macro. Confirmer le type de post-processeur utilisé (Fanuc, Siemens, Heidenhain ou ISO RS-274), car les conventions de codage et les jeux de codes M varient significativement.

Cinématique machine et limites d’axes : Nombre d’axes (3/4/5), courses d’axes, vitesse d’avance maximale (mm/min ou IPM), accélération maximale (mm/s² ou in/s²), et profils de jerk ou de mouvement à jerk limité si disponibles. Ces paramètres définissent l’avance réellement atteignable sur les petits mouvements et le comportement de lissage (blending).

Caractéristiques broche et outils : Plage de vitesse broche (S), liste d’outils avec correcteurs, nombre de changements d’outil par pièce, et temps de changement d’outil documentés (indexation tourelle ou carrousel ATC). Les changements d’outil automatiques varient typiquement de 8 à 45 secondes selon le type de tourelle ou d’ATC.

Bridage et contexte du programme : Contraintes de bridage, temps de changeur de palette, séquences de palpage, et étapes manuelles de chargement/déchargement. Les cycles de palpage et interventions opérateur ajoutent des minutes non-productives par cycle.

Codes spécifiques au contrôleur : Identifier les codes G/M courants du programme (G0/G1/G2/G3, F, S, M6, M30, M01). Repérer aussi les codes M propriétaires et les appels de macro, qui déclenchent des fonctions machine absentes du G-code ISO standard.

Point clé : tenter d’estimer le temps de cycle uniquement à partir du texte du programme est trompeur. L’absence de spécifications machine conduit fréquemment à des estimations trop optimistes, car les petits mouvements sont contraints par l’accélération et l’anticipation (look-ahead), et non par la vitesse d’avance nominale. Une collecte de données complète réduit la variance et permet une simulation plus fidèle par la suite.

Étape 2 : comment analyser le G-code (mouvements, vitesses d’avance et commandes modales) ?

Une analyse robuste du G-code nécessite de « tokeniser » les blocs et de maintenir un état modal persistant. Chaque ligne (bloc) contient des tokens (ex. G1 X10 Y5 F2000), et l’analyseur doit suivre les modes actifs tels que le mode d’avance (G94/G95), le mode de déplacement (G90/G91), le plan de travail, l’état de la broche et les correcteurs d’outil actifs.

Tokenisation et état modal : Lire chaque bloc et mettre à jour l’état modal. Si un bloc définit F (avance), cette valeur s’applique aux mouvements de coupe suivants jusqu’à modification. G0 représente un mouvement rapide (non-productif), G1 une interpolation linéaire à l’avance programmée, G2/G3 des arcs horaires/antihoraires.

Distinction mouvements rapides et de coupe : Traiter G0 comme un mouvement rapide exécuté à la vitesse rapide maximale de la machine, souvent soumis à des limites spécifiques par axe. Les mouvements de coupe (G1, G2, G3) utilisent l’avance courante. Convertir les unités d’avance (mm/min vs IPM) selon les déclarations G20/G21.

Gestion des arcs et linéarisation : Les arcs (G2/G3) doivent être convertis en segments linéaires si le moteur de simulation ne gère pas nativement l’interpolation circulaire pure. Le choix de la tolérance de segmentation d’arc impacte le calcul de temps : des tolérances plus fines génèrent plus de segments et des vitesses de lissage légèrement différentes. Pour la plupart des estimations, une tolérance de corde de 0,01 à 0,1 mm offre un bon équilibre précision/performance.

Longueur d’arc, concrètement : pour un arc, calculer la longueur à partir des points de départ et d’arrivée et du centre ou du rayon : longueur d’arc = rayon × angle (en radians). Si le G-code fournit les décalages de centre I/J, calculer l’angle avec atan2 et le normaliser. Exemple : un arc de 90° de rayon 10 mm donne une longueur de 10 × π/2 ≈ 15,71 mm ; à 600 mm/min, cela fait 1,571 seconde. Appliquer l’avance programmée à la longueur d’arc donne une estimation de temps de base.

Cycles fixes, macros et sous-programmes : Reconnaître les cycles fixes (G81/G83) comme des opérations de haut niveau avec dégagements et temporisations implicites. Développer les appels de sous-programme (M98) ou macros en séquences de mouvement avant simulation. Les macros spécifiques au constructeur peuvent déclencher des actions personnalisées (ex. bridage hydraulique) nécessitant des durées associées.

Cas particuliers : Gérer les changements d’avance en milieu de bloc (certains contrôleurs autorisent une modification de S ou F sans mouvement explicite), les temporisations (G4) qui ajoutent des secondes, et les programmes « multi-fichiers » qui appellent des fichiers externes.

Des analyseurs open source comme pygcode (Python) et des outils communautaires offrent de bons points de départ, mais les constructeurs utilisent souvent des codes M propriétaires. Les contrôleurs Fanuc ou Siemens nécessitent donc un traitement spécifique. Une analyse qui respecte l’état modal et développe les macros garantit que la couche de simulation reçoit une séquence de mouvement complète et linéarisée.

Étape 3 : comment simuler le programme pour estimer le temps de cycle brut ?

Sommation naïve

Calculer la distance euclidienne de chaque mouvement de coupe et la diviser par l’avance programmée (distance ÷ avance). Traiter les rapides séparément avec les limites de vitesse rapide. Cette méthode suppose que la machine atteint instantanément l’avance commandée, une hypothèse optimiste. Les audits d’atelier montrent que les méthodes naïves peuvent sous-estimer le temps de cycle de 10 à 40 % sur des trajectoires à nombreux petits mouvements ou à forte accélération. En effet, l’accélération et l’anticipation réduisent l’avance effective sur les segments courts.

Simulation cinématique

Modélise les accélérations, décélérations, le jerk et le lissage/l’anticipation entre axes. Cette approche utilise un profil machine (avance maximale, accélération par axe, jerk maximal, anticipation) pour simuler comment le contrôleur lisse les transitions et limite les vitesses dans les virages. Les simulateurs cinématiques prédisent les zones où l’avance programmée ne peut être atteinte et calculent le temps en conséquence.

Exemple : un mouvement linéaire de 50 mm à 6 000 mm/min avec une limite d’accélération de 0,5 g atteindra rarement l’avance nominale avant de devoir décélérer, augmentant le temps par rapport aux estimations naïves.

Les écarts cinématiques sont particulièrement marqués sur :

• Les passes de finition courtes à haute vitesse
• L’usinage simultané 5 axes avec limites d’axes coordonnées
• Les programmes à séquencement complexe et petits rayons d’arc

Corrections par règles pour les petits mouvements et les changements de direction

Quand vous ne disposez pas de toutes les données d’accélération et de jerk pour un modèle physique, utilisez des corrections par règles. Repérez les mouvements de moins de 50 mm environ et multipliez leur temps à vitesse stabilisée par 2 à 5 selon l’accélération estimée. Ajoutez ensuite 5 à 15 % pour les inversions de direction et les séries de petits mouvements successifs. Testez la sensibilité en faisant varier l’hypothèse d’accélération de ±10 % et en observant l’écart sur le temps de cycle total : beaucoup de programmes de petites pièces changent sensiblement avec cette seule hypothèse.

Un bloc G-code entièrement détaillé

Pour rendre concret le passage de l’analyse à l’estimation de temps, voici un programme court détaillé bloc par bloc :

N10 T1 M6
N20 G0 G90 X0 Y0 Z100
N30 G1 Z-5 F300
N40 G1 X30 Y0 F300
N50 G1 X30 Y30 F300
N60 G0 Z100
N70 M30

• Changement d’outil (M6) : utiliser un temps de changement d’outil mesuré ou standard (par exemple 6 s pour une tourelle automatique, 18 à 60 s en manuel).
• G0 vers Z100 : mouvement rapide ; avec environ 12 m/min de rapide sur 100 mm, comptez environ 0,5 à 1,0 s avec l’accélération.
• G1 Z-5 à F300 mm/min (5 mm/s) sur une plongée de 105 mm (de 100 à -5) : environ 21 s (estimation prudente pour une longue plongée).
• Mouvements linéaires XY : 30 mm à 5 mm/s, soit 6 s chacun.

La somme des temps de blocs et des événements auxiliaires donne une estimation brute du cycle du programme.

Les outils visuels comme les backplots FAO et les simulateurs CNC (Mastercam, Siemens NX, Autodesk Fusion 360, ou NCViewer) illustrent les mouvements et peuvent calculer des estimations de temps de cycle. Le suivi de production sert de source de validation complémentaire : relier la simulation de mouvement aux enregistrements d’axes et de broche permet d’affiner les profils cinématiques.

Étape 4 : comment intégrer le temps non-productif (changements d’outil, palpage, réglages et interventions manuelles) ?

Le temps non-productif représente souvent la majorité de la variance de cycle et doit être modélisé explicitement.

Changements d’outil : Les temps de changeur d’outil automatique (ATC) varient d’environ 8 secondes (tourelle) à 30-45 secondes (carrousel ATC à bras long). Les changements d’outil manuels prennent plus de temps : mesurer au chronomètre ou extraire les horodatages. Inclure à la fois le changement physique et le temps d’indexation tourelle/repositionnement broche.

Cycles de palpage : Les cycles de palpage (sondes de mesure) peuvent ajouter 10 à 60 secondes par pièce selon la complexité et le repositionnement. Le palpage programmé (macros de sonde ISO) s’appuie généralement sur des codes M ou macros spécifiques au contrôleur : analyser ces éléments et leur assigner des durées mesurées.

Chargement/déchargement et changements de palette : Le chargement manuel pièce-à-pièce peut prendre 30 à 120 secondes ; les changeurs de palette automatiques ont des temps d’indexation documentés (ex. 20-90 secondes). Pour les cellules robotisées, inclure le temps de cycle et l’indexation du robot.

Réglages et bridage : Les réglages de première pièce et ajustements de bridage doivent être amortis sur la taille du lot. Exemple : un réglage de 30 minutes amorti sur 1 000 pièces ajoute 1,8 seconde par pièce.

Interventions opérateur et contrôles : Les contrôles qualité manuels, le réapprovisionnement en liquide de coupe ou l’éjection de pièce peuvent ajouter des délais variables. Les mesurer via des études de temps ou des journaux d’événements I/O machine.

Les études de temps empiriques et les journaux TRS/machine sont recommandés pour renseigner les durées non-productives. La télémétrie machine réelle révèle souvent que les éléments non-productifs représentent 20 à 50 % du temps de cycle total de la pièce en environnement petites séries ou forte variété. Les modéliser avec précision est donc essentiel pour une planification des effectifs et un takt time fiables.

Étape 5 : comment convertir le temps de cycle en temps standard exploitable pour la planification et les effectifs ?

Le temps de cycle (observé ou simulé) ne devient exploitable qu’une fois converti en temps standard, utilisé par les planificateurs pour les devis, la planification de capacité et la gestion des effectifs. Le temps standard intègre les coefficients de performance, les marges, le rebut/retouche et l’amortissement des réglages. Rangez ensuite chaque temps standard dans la gamme opératoire de la pièce, opération par opération.

1. Assembler le temps de base par unité : Additionner le temps de coupe simulé et les éléments non-productifs mesurés empiriquement (changement d’outil, chargement/déchargement, palpage). Exemple : temps de coupe brut = 2,00 min, changement d’outil amorti par pièce = 0,50 min, chargement/déchargement = 0,75 min → temps de base observé = 3,25 min.

2. Appliquer le coefficient de performance : Si la machine ou l’opérateur est évalué avec un facteur de performance (ex. 95 % d’efficacité machine ou évaluation de performance opérateur), diviser le temps observé par ce facteur. Exemple : 3,25 min ÷ 0,95 = 3,42 min.

3. Ajouter les marges : Intégrer des tolérances pour le repos et les imprévus. Les marges totales typiques vont de 5 à 15 % selon la politique de l’atelier (pauses courtes, contrôles machine, micro-arrêts). Exemple : 3,42 min × 1,10 = 3,76 min de temps standard par unité.

4. Ajuster pour la taille du lot et l’amortissement du réglage : Pour les petites séries, le temps de réglage par pièce augmente. Pour un réglage de 30 minutes amorti sur 100 pièces, ajouter 0,30 min par pièce. Toujours présenter le temps standard avec la taille de lot supposée.

5. Intégrer le facteur rebut/retouche : Si le procédé affiche historiquement 2 % de rebut, ajuster la capacité en conséquence : production effective par série planifiée = pièces planifiées × (1 − taux de rebut).

Repères plus précis pour le chargement/déchargement et le contrôle

Voici des valeurs typiques mesurées, utiles comme contrôle de cohérence avant de réaliser vos propres études de temps :

• centre d’usinage avec changeur de palette : chargement/déchargement de 12 à 25 s ;
• tour manuel à mandrin simple : chargement/déchargement de 20 à 45 s ;
• contrôle/calibrage : de 10 à 30 s selon la complexité.

Documentez-les comme éléments d’opération et conservez-les par ID d’opération, en utilisant de courtes études de temps (5 à 10 cycles) pour obtenir des valeurs cohérentes.

Du temps standard au débit et au takt time

Une fois le temps standard validé, traduisez-le directement en KPI de planification.

Débit : pièces par poste = (secondes du poste) / (temps standard). Exemple : un poste de 8 heures = 28 800 s. Avec un temps standard de 225,6 s (les 3,76 min de l’exemple ci-dessus), cela donne environ 128 pièces par poste et par machine.

Takt time : takt = temps de production disponible / demande client.

Des temps standards précis donnent tout son sens au facteur Performance de TRS = Disponibilité × Performance × Qualité et empêchent les planificateurs de surcharger les machines. Pour une présentation complète de l’indicateur, voir notre guide du calcul du TRS.

Application pratique

Pour convertir en capacité par poste ou par jour, multipliez le temps standard par le nombre de pièces par poste et comparez aux heures machine disponibles. Utilisez l’alignement sur le takt time lors de la planification pour que la production suive la demande. Des études de cas réelles montrent que l’optimisation de la programmation peut réduire le temps standard et générer des économies mesurables pour les petits ateliers. Elle passe par une meilleure structure des programmes et de meilleures stratégies d’avance et d’approche.

Étape 6 : quelles méthodes et outils utiliser ? Tableau comparatif et spécifications

Certaines approches ci-dessous sont des calculs sur texte réalisés sur le G-code lui-même, avant l’usinage. D’autres sont des mesures de terrain relevées sur l’atelier ou le contrôleur, pendant ou après l’usinage. Elles ne sont pas interchangeables : une estimation sur texte dit ce qu’un programme devrait durer, une mesure de terrain dit ce qu’il a réellement duré.

Pour chiffrer des pièces à l’unité, des tableurs ou des backplots FAO peuvent suffire s’ils sont associés à des marges conservatrices. Pour une planification à l’échelle de l’atelier et un ordonnancement automatisé, un simulateur cinématique ou une solution d’extraction commerciale prenant en charge les profils machine et les connecteurs ERP/MES se rentabilise en réduisant la variance.

La mesure de terrain (monitoring en périphérie, journaux du contrôleur) sert ensuite à valider et corriger l’estimation sur texte de départ (voir l’étape 7). Les bibliothèques open source comme pygcode permettent la personnalisation ; les outils commerciaux fournissent des connecteurs (REST, OPC-UA, API MES natives) et du support. Pour transformer ces temps en prix, voir notre article sur le chiffrage de devis d’usinage avec des temps standards.

Choisir selon la taille de l’atelier et le budget

Petits ateliers à budget serré : estimations FAO + validation manuelle périodique : faible investissement, précision de 5 à 10 %, maintenance minimale. Ateliers moyens : journaux du contrôleur + analyse périodique : investissement modéré, précision de 2 à 5 %, nécessite des compétences IT et contrôleur. Ateliers de haute précision : monitoring en temps réel en périphérie + réconciliation avec la simulation : investissement plus élevé, précision <3 %, nécessite maintenance et intégration continues.

Si le budget est serré et que la variété est faible, commencez par l’analyse FAO et une validation ponctuelle sur 10 cycles. Si la variété ou la variabilité des livraisons est moyenne, ajoutez les journaux du contrôleur sur les machines à fort volume. Si les plannings exigent un contrôle serré en temps réel, ou plusieurs équipes avec des passations complexes, déployez le monitoring en périphérie et des flux TRS automatisés.

Estimez le retour avec vos propres chiffres. Si une meilleure précision des temps réduit la marge de sécurité du planning et augmente le débit de quelques pourcents, calculez ce que valent ces pièces ou ces heures pour votre atelier, puis comparez-le au coût de la solution.

Feuille de route de mise en œuvre : gains rapides ou automatisation à long terme

Gains rapides : lancer un pilote sur 3 à 5 pièces récurrentes ; réaliser des études chronométrées pour les changements d’outil et le chargement/déchargement ; utiliser des modèles de tableur avec marges conservatrices.

Moyen terme : adopter des analyseurs open source avec des scripts par lots pour analyser et développer les sous-programmes ; ajouter une vérification par backplot FAO.

Long terme : déployer un simulateur cinématique ou une plateforme d’extraction commerciale avec profils machine, et pousser les temps standards validés vers le MES/ERP.

Les constructeurs de contrôleurs (Fanuc, Siemens) et les systèmes FAO (Mastercam, Fusion 360, Siemens NX) sont des points d’intégration courants. Évaluez les plateformes sur la précision, la prise en charge des profils machine, la disponibilité d’API et leur capacité à importer les tables de correcteurs d’outils et les variantes de post-processeur.

Étape 7 : comment valider, automatiser et intégrer les temps extraits avec le MES/ERP ?

Étapes de validation

Comparer à la télémétrie machine : Utiliser les horodatages de mise sous tension broche, les mouvements d’axes et les journaux d’événements codes M pour calculer les durées de cycle réelles. Suivre des métriques comme l’erreur absolue moyenne (MAE) et le pourcentage de précision. Viser une MAE inférieure à 5-10 % pour la planification de production.

Définir des KPI : Suivre la précision (% de pièces dans la tolérance), la variance (écart-type) et le taux de prédictions hors limites. Analyser régulièrement les KPI par famille de pièces et type de machine.

Piloter et ajuster : Lancer un pilote sur des pièces répétitives pour calibrer les accélérations machine et les temps de changement d’outil ; ajuster les profils cinématiques et les valeurs par défaut de temps non-productif.

Taille d’échantillon et suivi statistique

Une base pratique est de 10 à 20 cycles pour la validation initiale, un compromis entre rapidité et utilité statistique. Quand la variabilité est importante (usure d’outil, remplissage du liquide de coupe), montez à 50 cycles ou plus, répartis sur plusieurs équipes, pour capturer les motifs journaliers.

Suivez l’erreur absolue moyenne en pourcentage (MAPE : moyenne de |(observé − prédit)/observé| × 100, cible inférieure à 5 % pour la plupart des ateliers) et l’écart-type pour comprendre la variabilité du procédé. Traitez les événements au-delà de 2σ comme des valeurs aberrantes à analyser. Fixez des limites de contrôle, surveillez avec une simple carte de contrôle MSP (maîtrise statistique des procédés) et revalidez après des modifications de programme, de nouveaux outils ou des changements importants de procédé.

Modèles d’automatisation

Intégration continue de la FAO vers l’analyseur : Automatiser la chaîne : post-processeur FAO → dépôt G-code → analyseur/simulateur → base de données. Permet un recalcul immédiat à chaque modification de programme.

Mises à jour événementielles : Redéclencher la simulation quand le post-processeur ou la liste d’outils change. Utiliser le versionnage pour suivre les révisions de programme et leur impact sur le temps de cycle.

Trois modèles d’intégration

Périphérie vers MES en temps réel : utiliser un boîtier en périphérie (MTConnect/OPC-UA) ou un connecteur JITbase pour envoyer les événements d’exécution et les temps de cycle vers les tableaux de bord MES/TRS, en quasi temps réel.

Synchronisation par API : envoyer les temps standards validés et leurs métadonnées via des API REST vers les modules d’ordonnancement ou de planification de l’ERP.

Import par lots : exporter des CSV ou des exports planifiés des temps d’opération validés vers l’ERP pour une mise à jour en masse.

Pour les ateliers qui ont besoin d’un retour quasi temps réel pour l’ordonnancement et l’affectation, utilisez OPC-UA ou des API REST associés à une plateforme en périphérie pour diffuser les événements.

Bonnes pratiques d’intégration

Conception de la charge utile (payload) : Les charges utiles (payloads) de temps standard incluent typiquement : ID de l’opération, temps standard par unité (secondes/minutes), liste d’outils, temps non-productif attendu, ID de révision.

Exemple JSON :

{ "operation": "OP10", "std_time_min": 3.76, "tools": ["T1","T4"], "revision": "v1.2" }

Méthodes d’intégration : Les modèles courants incluent les API REST (la plupart des MES/ERP modernes), l’OPC-UA pour la télémétrie temps réel, et les imports CSV en masse pour les anciens systèmes.

Pièges courants d’intégration

• Identifiants incohérents : standardiser les noms de programmes et les identifiants d’opération entre les systèmes.
• Bases de temps différentes : normaliser les horodatages en UTC ou en heure locale de l’atelier, et tenir compte de la dérive d’horloge.
• Données partielles : s’assurer que les développements de sous-programmes et les événements auxiliaires sont enregistrés ; les analyseurs qui les omettent produisent des sous-estimations.
• Contraintes des anciens contrôleurs : pour les contrôleurs anciens sans réseau, utiliser une passerelle en périphérie qui lit la charge broche ou des entrées numériques pour déduire les cycles.

Prévoyez une liste de points de contrôle d’intégration : correspondance des champs, fréquence de synchronisation, gestion des erreurs et règles de réconciliation. Tester sur un ensemble pilote de machines et d’opérations avant le déploiement à l’échelle de l’entreprise réduit les mauvaises surprises.

Suivi de production automatisé : Combiner les temps issus du G-code avec le suivi de production atelier pour capturer les horodatages réels de validation.

Scénario d’intégration pratique : un atelier automatise l’analyse du G-code, simule avec les profils machine et envoie les temps standards vers les gammes de l’ERP. Les données TRS en temps réel comparent ensuite le prévu au réel, et une tâche nocturne recalibre les profils machine lorsque la variance dépasse les seuils. Pour profiter d’un ordonnancement en temps réel, associez les temps validés aux données en temps réel afin d’améliorer le respect des délais et de réduire les goulots d’étranglement.

Erreurs fréquentes et dépannage

Ignorer le comportement propre au contrôleur sur les cycles fixes

Symptôme : les cycles de perçage calculés sont systématiquement plus rapides que les mesures. Test : développer les cycles fixes et comparer avec le simulateur du contrôleur. Correction : implémenter le développement des cycles fixes propre au contrôleur, ou réaliser une marche à blanc sur le contrôleur pour valider.

Sous-estimer l’accélération et les pénalités des petits mouvements

Symptôme : les séries de petits mouvements montrent un fort écart en pourcentage. Test : isoler les mouvements de moins de 50 mm et les exécuter sur la machine avec des horodatages d’E/S ou une caméra. Correction : appliquer un modèle d’accélération ou des facteurs de correction pour petits mouvements.

Se fier à une seule mesure au lieu d’échantillons agrégés

Symptôme : le temps standard varie d’une exécution à l’autre. Test : calculer la médiane sur 5 à 10 exécutions et vérifier la variabilité. Correction : utiliser la médiane ou le mode et noter le contexte (opérateur, taille de lot).

Oublier les marges opérateur et manutention

Symptôme : les objectifs de débit ne sont pas atteints malgré la disponibilité des machines. Test : chronométrer séparément le chargement/déchargement et les contrôles. Correction : intégrer les temps de manutention par pièce et les marges de réglage par lot.

Quand l’écart entre calculé et mesuré dépasse 15 %, vérifiez dans l’ordre :

• relancer l’analyse et confirmer que la version du G-code correspond au fichier chargé dans le contrôleur ;
• capturer les signaux d’E/S en direct (broche, pièce présente) et aligner les horodatages ;
• vérifier les durées de changement d’outil et de palpage dans les journaux en direct ;
• réaliser des études de temps ciblées sur les segments problématiques et mettre à jour le profil machine.

Si l’écart persiste, menez une étude longitudinale sur plusieurs équipes et opérateurs pour repérer la variabilité humaine ou liée au procédé. Si l’écart se répète sans cause évidente, notre guide de diagnostic de l’écart de temps de cycle classe les causes probables par symptôme.

Ce que le temps de cycle révèle sur vos goulots d’étranglement

Au-delà du calcul lui-même, l’exploitation de temps de cycle fiables sert un objectif plus large : identifier les goulots d’étranglement. Lorsqu’une machine affiche des temps systématiquement plus longs que les autres pour un travail comparable, elle devient un point de blocage qui ralentit le flux de production et accumule de l’en-cours en amont. L’analyse des KPI de production permet d’identifier ces points critiques pour une action ciblée (rééquilibrage de charge ou optimisation du processus) afin d’améliorer la fluidité opérationnelle et la capacité globale.

Tableau comparatif, de l’estimation à la réalité :

Impact chiffré : à titre d’illustration, une dérive de 15 % sur le temps de cycle, sur 1 000 heures de production, représente environ 150 heures de capacité que le planning ne voit pas. Ce sont plusieurs heures de production perdues chaque semaine sur les machines concernées. Les ateliers qui suivent précisément leur performance récupèrent une partie de cette capacité grâce à une meilleure gestion des flux, moins d’en-cours et une charge machine optimisée. L’ampleur du gain dépend de l’atelier : mesurez votre situation de départ avant et après le pilote.

Le point clé à retenir

Suivez ces sept étapes pour transformer le G-code en temps standards validés. Collectez des données machine et outils complètes, analysez et simulez avec fidélité cinématique, intégrez les activités non-productives, convertissez en temps standards avec marges, puis automatisez la validation et l’intégration MES/ERP. Commencez par un pilote ciblé sur des pièces répétitives, affinez avec la télémétrie machine, puis déployez à l’échelle de l’atelier.

Les ateliers qui automatisent l’analyse et la validation du G-code ont besoin de moins d’études de temps manuelles et chiffrent plus vite. Le gain dépend de la taille de l’atelier et de la variété des travaux : mesurez les heures de planification que vous consacrez aujourd’hui aux devis répétitifs pour l’évaluer.

Plan d’action en 30 jours pour augmenter la productivité avec des temps fiables

Semaine 1 : cadrage et choix des références

• sélectionner 5–10 références répétitives (80/20)
• lister les opérations critiques
• identifier la source « temps réel » disponible (contrôleur, monitoring, relevés).

Semaines 2–3 : extraction + validation

• analyse (parsing) NC des programmes
• collecte des temps réels sur 10–20 cycles
• standardisation des auxiliaires
• calcul MAPE + corrections.

Semaine 4 : intégration et pilotage KPI

• injecter standards dans MES/ERP
• configurer les tableaux de bord : charge, capacité, écarts standard/réalisé
• suivre : productivité, heures/part, stabilité planning, TRS/OEE (si applicable).

À la fin du mois, vous devez être capable de dire :

• « nos standards sont fiables sur X opérations »
• « notre planning a gagné en stabilité »
• « notre suivi des performances est exploitable »
• « voici où nous allons augmenter la productivité (leviers concrets) »

Foire aux questions

Quelle est la précision des temps de cycle dérivés du G-code ?

Cela dépend fortement de la méthode utilisée. La sommation naïve distance/avance suppose que la machine atteint instantanément l’avance commandée, une hypothèse optimiste qui peut sous-estimer le temps de cycle de 10 à 40 % sur les programmes à nombreux petits mouvements ou fortes accélérations, car l’accélération et l’anticipation limitent l’avance effective sur ces segments courts.

La simulation cinématique, qui modélise l’accélération, le jerk et le lissage entre axes à partir d’un profil machine complet, atteint typiquement 1 à 8 % de précision une fois calibrée sur la télémétrie machine. Dans les deux cas, la validation contre les horodatages de mise sous tension broche et les journaux TRS, idéalement sur 10 à 20 cycles pour une première passe, reste indispensable pour quantifier la précision réelle propre à votre parc machine et à vos familles de pièces.

Peut-on extraire les temps pour des programmes multi-axes ou 5 axes simultanés ?

Oui, mais l’usinage simultané 5 axes élève sensiblement le niveau d’exigence. Il nécessite une modélisation cinématique complète des axes rotatifs, de leur couplage avec les axes linéaires, et des limites de vitesse et d’accélération propres à chaque axe. Un simple calcul distance/avance sera nettement moins fiable ici que sur de l’usinage 3 axes classique.

Les contrôleurs comme Fanuc et Siemens appliquent des règles de lissage et d’anticipation différentes pour les mouvements simultanés multi-axes. Il faut donc utiliser les paramètres cinématiques réels de la machine plutôt que des valeurs par défaut génériques, et tester avec des programmes de production représentatifs. Prévoyez davantage de temps de calibration et de validation par télémétrie pour atteindre une précision inférieure à 5 % sur du travail 5 axes, contre 1 à 8 % typiquement atteignables sur des programmes 3 axes plus simples.

Comment gérer les codes M propriétaires et les macros ?

Commencez par documenter chaque code M spécifique réellement utilisé dans votre atelier, et associez chacun à une action chronométrée (un bridage hydraulique, une commande de liquide de coupe ON/OFF, un changement de magasin d’outils) plutôt que de l’ignorer comme un élément inconnu du modèle. Lors de l’analyse, développez ou intégrez les sous-programmes et appels de macro pour que la couche de simulation reçoive une séquence de mouvement complète et linéarisée, plutôt qu’une simple référence opaque à une macro.

Pour convertir ces événements en secondes dans votre modèle, mesurez les durées réelles via une étude de temps courte ou en extrayant des horodatages depuis les journaux API/PLC, plutôt que d’estimer à vue. Le comportement des macros variant selon le contrôleur, maintenez une bibliothèque de contrôleur distincte par modèle de machine (Fanuc, Siemens, Heidenhain) pour que le mappage reste précis et reproductible à mesure que vous ajoutez des machines.

Quelle est la meilleure façon de valider les estimations G-code sur le terrain ?

Comparez vos temps simulés à la télémétrie machine (horodatages de mise sous tension et d’arrêt broche, événements de mouvement d’axes) plutôt que de faire confiance à la seule sortie de la simulation. Calculez des KPI comme l’erreur absolue moyenne (MAE) et le pourcentage de pièces dans votre tolérance, et suivez-les par famille de pièces et type de machine plutôt que comme un chiffre unique à l’échelle de l’atelier.

Utilisez le suivi de production automatisé ou les journaux d’événements PLC pour collecter des horodatages de référence fiables : se fier à la mémoire de l’opérateur introduit sa propre marge d’erreur et fausse la comparaison. Ajustez ensuite votre profil machine (accélération, jerk, valeurs par défaut de temps non-productif) jusqu’à ce que les objectifs de précision soient atteints de façon constante pour chaque famille de machine, puis revalidez périodiquement à mesure que l’outillage ou les programmes évoluent.

Les temps standards extraits peuvent-ils être utilisés en confiance pour la planification de capacité ?

Oui, à condition qu’ils soient correctement validés. Les temps standards extraits ne doivent pas être utilisés pour la planification de capacité directement en sortie du simulateur. Visez une précision cohérente, de l’ordre de 5 à 10 %, et documentez explicitement vos hypothèses : la taille de lot utilisée, les marges appliquées et la taille de l’échantillon derrière la validation.

Intégrez les temps validés dans votre MES/ERP pour que les planificateurs travaillent toujours avec les derniers standards plutôt qu’avec un export de tableur obsolète. Tout aussi important, maintenez une boucle de rétroaction avec les données TRS et le suivi atelier pour détecter la dérive tôt : usure d’outil, modification de programme ou nouveau bridage peuvent tous éloigner le temps de cycle réel de votre validation initiale. Ne revalider que lorsque la variance augmente permet de garder des standards fiables sans surcharge de gestion excessive.

Combien de pièces faut-il mesurer pour valider un temps de cycle de manière fiable ?

Commencez par 10 à 20 cycles pour une première validation : c’est un bon compromis entre rapidité et utilité statistique, et c’est la base retenue dans le plan en 30 jours ci-dessus. Pour des opérations très longues, où chaque mesure coûte du temps de production, 3 à 5 cycles peuvent servir de premier contrôle, à compléter dès que possible.

Quand la variabilité est forte (usure d’outil, remplissage du liquide de coupe, plusieurs équipes ou plusieurs opérateurs), montez à 50 cycles ou plus, répartis sur plusieurs équipes, pour capturer les écarts de pratique. L’objectif est un biais inférieur à 5 % entre temps mesuré et temps extrait, un seuil suffisant pour que la planification et le suivi de performance restent fiables sans exiger un volume de mesures disproportionné par rapport au gain de précision obtenu.

Les données de charge broche aident-elles à améliorer la précision ?

Les signatures de charge et de puissance de la broche sont très utiles pour détecter l’engagement de l’outil, les outils cassés et les déplacements à vide qu’un simple analyseur de G-code peut totalement manquer, puisque le texte du programme ne révèle pas ce que la broche a réellement subi pendant un mouvement. Elles aident aussi à distinguer le temps de coupe actif des mouvements non productifs plus précisément que l’analyse de l’état modal seule.

Croiser les courbes de charge broche avec l’analyse du programme peut révéler des temporisations ou des blocages cachés (un outil qui frotte sans couper, par exemple) et améliorer la classification des cycles. De nombreuses plateformes de monitoring en périphérie ingèrent déjà les données de charge broche pour affiner la détection des cycles et signaler les anomalies en temps réel, avec de simples seuils ou des modèles d’apprentissage automatique légers pour repérer ce que l’analyse seule laisserait passer.

Cette méthode remplace-t-elle un logiciel de gestion des temps ou de WFM ?

Non, elle les complète et ne s’y substitue pas. L’extraction de temps depuis le G-code fournit des données d’entrée fiables (temps machine validés) qui alimentent ensuite les outils de gestion des temps, de gestion des effectifs (WFM) ou de planification avancée déjà en place dans l’atelier.

Sans données réalistes en amont, même un excellent logiciel de planification produit des résultats erronés, car il ne fait qu’automatiser des calculs à partir des chiffres qu’on lui fournit. La qualité du suivi des KPI dépend donc d’abord de la qualité des temps utilisés en entrée, avant même le choix de l’outil de planification. En pratique, les ateliers qui obtiennent les meilleurs résultats combinent une extraction G-code rigoureuse avec le WFM ou l’ERP existant, plutôt que de chercher un outil unique qui ferait les deux.

Faut-il mettre à jour les temps standards régulièrement ?

Oui. Les standards de temps ne sont pas figés : ils évoluent avec les outils utilisés, les révisions de programme, les opérateurs et l’organisation de l’atelier, et un standard non révisé finit toujours par s’éloigner de la réalité. Bonne pratique : versionnez chaque standard avec un identifiant de révision, et documentez systématiquement la date et le contexte de validation (taille d’échantillon, machine, conditions).

Redéclenchez une validation dès que la variance mesurée dépasse un seuil défini, typiquement 10 % d’écart entre temps standard et temps réel observé. Cette discipline de versionnage évite deux écueils classiques : des standards trop anciens qui faussent silencieusement la planification, et des mises à jour non documentées qui rendent impossible de comprendre pourquoi un temps a changé d’une version à l’autre.

Comment intégrer ces temps dans un ERP ou un MES sans perturber la production ?

Par une intégration progressive et contrôlée plutôt qu’un déploiement massif d’un seul coup. Les temps validés s’importent typiquement via CSV en masse ou API en temps réel, en ne mettant à jour que les champs directement concernés (temps opératoires, temps de réglage et capacités des postes de charge), sans toucher au reste de la configuration ERP/MES.

Commencez par une zone pilote limitée (une famille de pièces ou une machine critique) avant un déploiement global : cela limite le risque d’erreur de mapping entre identifiants d’opération, et donne aux planificateurs le temps de s’approprier les nouveaux standards avant qu’ils ne deviennent la référence pour tout l’atelier. Un format de charge utile structuré (avec ID d’opération, temps standard, liste d’outils et ID de révision) facilite cette synchronisation et la rend traçable dans la durée.