Post Processeurs
Le format des fichiers Gcode générés peut être contrôlé à l'aide des fichiers de définition des post processeurs. Ces définitions peuvent être crées, copiées et modifiées depuis la section Post Processeurs de l'onglet System.
Le post-processeur utilisé pour un projet spécifique est défini dans les options d'usinage.
Sélectionnez le dossier d'usinage (Machining) dans l'arborescence du projet et regarder dans le groupe Post Processor des propriétés d'usinage.
Si aucun post processeur n'est spécifié, un post processeur interne est utilisé, compatible avec la spécification RS274 NIST tel qu'il est utilisé par de nombreux contrôleurs CNC communs tels que Mach3, EMC et USBCNC.
|
PostProcessor
|
Cette option fournis une liste déroulante permettant de sélectionner un des post processeurs disponibles dans le dossier \post.
|
|
PostProcessorMacros
|
Cette option est utilisée pour passer des macro utilisateur au post processeur. C'est un texte multiligne contenant des définitions de macros au format $macro=valeur. Quelques exemples de macros sont donnés ci-dessous.
|
Si un fichier post processeur est modifié ou si un nouveau est crée en dehors de CamBam, la liste des post processeurs doit être
rafraîchie par le menu Tools – Reload Post Processors (Outils – Recharger Post processeur)
Pour définir un post processeur par défaut pour tout nouveau projet, vous devez sauver un fichier projet vide (.cb) dans lequel vous aurez
défini le post processeur à utiliser. Dans les options générales (menu Tools – Options) sous la section Divers, vous devrez définir ce
fichier comme modèle par défaut dans la propriété DrawingTemplate. (chemin d'accès du fichier) en cliquant sur le symbole
qui apparaît après sélection de la ligne pour ouvrir un sélecteur de fichiers.
Les post processeurs sont des fichiers XML avec une extension .cbpp situés dans le sous dossier \post du dossier système de CamBam.
Sections du post processeur
Le fichier XML contient un certain nombre de sections. Chaque section peut contenir un mélange de texte littéral, qui est transcrit
directement dans le fichier Gcode de destination, et des macros texte au format ${format}. Les définitions de macros sont définies dans le
fichier. cbpp, en interne par le post-processeur, ou en définissant des macros utilisateur dans l'option d'usinage PostProcessorMacros du projet.
Les macros sont évaluées et les valeurs texte qui en résultent sont écrites dans le Gcode.
Si des sections de la liste suivante ne sont pas visibles dans les propriétés, assurez-vous que vous êtes en mode Avancé (Advenced) dans l'éditeur de propriétés.
(Main) - PostFile
Cette section définit la structure générale du fichier gcode. Elle comprend généralement trois macros qui sont évalués en interne à partir des règles définies dans d'autres sections du fichier .cbpp
{$header} - Cette macro est évaluée en utilisant la section <header> décrites ci-dessous.
{$mops} - Cette macro est évaluée comme une liste de blocs de texte, un bloc pour chaque opération d'usinage. Chaque bloc est formaté en utilisant les règles de la section <MOP>.
{$footer} - Cette macro est évaluée en utilisant la section <footer> décrites ci-dessous.
Exemple:
%
O{$o}
( MY FANUC POST )
{$header}
G0 X10Y10Z0
{$mops}
{$footer}
%
Note: la valeur de la macro {$o} est passée au post processeur en utilisant la propriété PostProcessorMacro qui contiendra quelque chose comme '$o=1234'.
Le caractère % est écrit littéralement est sera omis si vous n'utilisez pas un programme de transfert de fichiers via le port RS232.
(Main) - Header
Définit les règles utilisées par la macro {$header}.
Exemple:
{$comment} {$cbfile.name} {$date} {$endcomment}
{$tooltable}
{$comment} CUTVIEWER {$endcomment}
{$comment} FROM/0,0,5 {$endcomment}
{$comment} TOOL/MILL,1,0,20.0,0 {$endcomment}
{$comment}STOCK/BLOCK,{$stock_width},{$stock_length},
{$stock_height},{$stock_x},{$stock_y},{$stock_z} {$endcomment}
{$cbfile.header}
{$units} {$distancemode} {$velocitymode} {$cuttercomp(off)}
{$toolchange(first)}
G54 ( Use fixture 1 )
{$clearance}
Une fois de plus, la propriété PostProcessorMacro est utilisée pour passer la macro {$stock_...} au post processeur qui, dans cet exemple pourrait contenir un texte comme:
$stock_length=150
$stock_width=150
$stock_height=12.7
$stock_x=75
$stock_y=75
$stock_z=12.7
(Main) - Footer
Définit les règles utilisées par la macro {$footer}.
Exemple:
{$clearance}
G28 G91 Z0
G90 G53 X-15.0 Y0.0
M09
{$spindle(off)}
{$endrewind}
(Main) - MOP
Defines how each item of the {$mops} macro is formatted.
This information will be repeated in the gcode output for each active machining operation.
Exemple:
{$comment} {$mop.name} {$endcomment}
{$toolchange}
{$velocitymode} {$workplane}
{$mop.header}
{$spindle} {$s}
{$blocks}
{$mop.footer}
Tools - ToolTableItem
Définit comment chaque entrée de la macro {$tooltable} est produite. Les tables d'outils sont généralement insérées dans l'en tête du fichier et contiennent un texte de commentaire décrivant la liste d'outils utilisés dans le fichier Gcode.
Exemple:
{$comment} T{$tool.index} : {$tool.diameter} {$endcomment}
Tools - ToolChange
Définit le formatage de la macro {$toolchange}.
Exemple:
{$clearance}
{$comment} T{$tool.index} : {$tool.diameter} {$endcomment}
{$comment} Tool Radius and Taper coming soon {$endcomment}
{$comment} TOOL/MILL, {$tool.diameter}, {$tool.radius},
{$tool.length}, 0 {$endcomment}
T{$tool.index} M6
G Codes - G0, G1, G2, G3, G81, G82, G83
Ces sections définissent le formatage des fonctions Gcode courantes.
Options - ArcCenterAbsolute
Utilisé dans la macro {$mop.header} pour spécifier ArcCenterMode en mode absolu. (G90.1 sous Mach3)
Options - ArcCenterIncremental
Utilisé dans la macro {$mop.header} pour spécifier ArcCenterMode en mode incrémental. (G91.1 sous Mach3)
G Codes - CutterCompOff, CutterCompLeft, CutterCompRight
[Nouveau 0.9.8h]
Utilisé dans la macro {$cuttercomp(off|L|R)}. Généralement Off=G40, Left=G41, Right=G42.
G Codes - CannedCycleStart
[Nouveau 0.9.8h]
Séquence de codes utilisés au début d'un bloc de cycle de perçage. Généralement G98 pour un retour au niveau initial à la fin du cycle.
G Codes - CannedCycleEnd
[Nouveau 0.9.8h]
Séquence de codes utilisés à la fin d'un bloc de cycle de perçage. Généralement G80.
G Codes - DistanceAbsolute, DistanceIncremental
[Nouveau 0.9.8h]
Généralement absolue=G90, incrémentale=G91. Note! Le mode incrémental n'est pas supporté pour l'instant.
G Codes - UnitsInches, UnitsMM
[Nouveau 0.9.8h]
inches=G20, millimeters=G21.
G Codes - VelocityModeExactStop, VelocityModeConstantVelocity
[Nouveau 0.9.8h]
exact stop=G61, constant velocity=G64.
G Codes - WorkplaneXY, WorkplaneXZ, WorkplaneYZ
[Nouveau 0.9.8h]
XY=G17, XZ=G18, YZ=G19.
G Codes - XModeDiameter
Utilisé dans la macro {$lathexmode} pour spécifier que les valeurs de X sont données en mode diamètre.(G7 sur EMC2).
G Codes - XModeRadius
Utilisé dans la macro {$lathexmode} pour spécifier que les valeurs de X sont données en mode rayon.(G8 sur EMC2).
M Codes - EndRewind
[Nouveau 0.9.8h]
Généralement M30.
M Codes - Repeat
[Nouveau 0.9.8h]
Généralement M47.
M Codes - SpindleCW, SpindleCCW, SpindleOff
[Nouveau 0.9.8h]
Généralement CW=M3, CCW=M4, Off=M5.
M Codes - Stop
[Nouveau 0.9.8h]
Généralement M0.
Moves - Rapid, FeedMove, ArcCW, ArcCCW
Cette section définit le formatage des fonctions Gcode de déplacement.
Exemple:
Rapid{$g0} {$_f} {$_x} {$_y} {$_z} {$_a} {$_b} {$_c}
FeedMove{$_g1} {$_f} {$_x} {$_y} {$_z} {$_a} {$_b} {$_c}
ArcCW{$g2} {$_f} {$_x} {$_y} {$_z} {$i} {$j}
ArcCCW{$g3} {$_f} {$_x} {$_y} {$_z} {$i} {$j}
Note: Les opérateurs gcode {$g...} et leurs paramètres peuvent être spécifiés en utilisant un préfixe trait de soulignement (_). Il s'agit de montrer les valeurs qui sont modales (persistantes). Elles ne seront écrites dans le code que si la valeur actuelle a changée.
L'omission du trait de soulignement force l'écriture du paramètre.
Canned Cycles - Drill, DrillDwell, DrillPeck
Cette section définit le formatage des fonctions Gcode de cycle de perçage.
Drill{$g81} {$_x} {$_y} {$_z} {$_r} {$_f}
DrillDwell{$g82} {$_x} {$_y} {$_z} {$p} {$_r} {$_f}
DrillPeck{$g83} {$_x} {$_y} {$_z} {$p} {$_q} {$_r} {$_f}
Lathe - LatheXMode
Pour les opérations de tournage, spécifie si les valeurs de X sont fournies en diamètre ou en rayon.
Options - ArcOutput
Détermine le mode de sortie des arcs dans le Gcode. Si a ConvertToLines, de courtes lignes seront utilisées à la place des arcs.
Options - ArcToLinesTolerance
Si ArcOutput=ConvertToLines est utilisé, cette valeur contrôle l'erreur maximum autorisée pour la conversion des arcs en lignes. Une faible tolérance produit des courbes plus lisses mais des fichiers plus gros.
Options - ClearancePlaneAxis
Utilisé pour définir dans quelle direction les déplacements vers le plan de dégagement seront fait. Généralement Z, mais doit être réglé à X ou Z pour les opérations de tournage.
Options - Comment, EndComment
Définit le texte qui sera utilisé au début et à la fin d'un commentaire.
Exemple 1:
Comment: (
EndComment: )
Exemple 2:
Comment: ;
EndComment:
Options - EndOfLine
[Nouveau 0.9.8h]
Séquence de caractère utilisée à la fin d'une ligne. Les codes d'échappement \r et \n peuvent être utilisés.
Options - InvertArcs
Si à true, les arcs en sens horaire seront sortis en arc anti-horaire et vice-versa. Cela peut être utile en usinage de face sur un tour.
Options - MinimumArcLength
Une valeur numérique qui contrôle la précision maximum utilisée pour la génération des déplacements en arcs de cercle (G2, G3).
Si la longueur d'un arc est inférieure à la valeur MinimumArcLength un mouvement en ligne droite (G1) est utilisé à la place.
Ceci est utile pour les utilisateurs de TurboCNC où des arcs très faibles peuvent causer quelques problèmes qui peuvent apparaître
comme des fossettes dans le parcours d'outil.
Exemple:
MinimumArcLength=1e-4
Options - MaximumArcRadius
Une valeur numérique qui contrôle le rayon maximum autorisé pour les déplacements en arc de cercle. Si le de l'arc rayon dépasse cette valeur, un mouvement en ligne droite (G1) est utilisé.
Exemple:
MaximumArcRadius=1e6
Options - NumberFormat
Il s'agit d'un modèle de formatage qui contrôle la façon dont les nombres à virgule flottante sont affichés.
Un caractère dièse (#) désigne un emplacement optionnel pour un chiffre et un caractère 0 représente un chiffre qui sera toujours affiché, en ajoutant des zéros de remplissage si nécessaire.
Cela peut aussi modifier les instructions Gcode nécessaires. Par exemple, si un parcours d'outil contient un passage de X = 1,234 à X = 1,233 et si un format de nombre de #. # 0 est utilisé, aucune instruction de mouvement ne sera écrite dans le Gcode car si elle sont formatées à 2 décimales, ces deux coordonnées sont identiques.
Options - RapidDownToClearance
[Nouveau 0.9.8i]
Si mise à False elle interdira la descente rapide depuis le plan de dégagement.
Options - UpperCase
Si la valeur est à True, le post-processeur convertit tout le texte écrit dans le fichier gcode en majuscules. Ceci est particulièrement utile pour les systèmes Fanuc qui ne supportent pas les caractères minuscules.
Post Build - PostBuildCommand and PostBuildCommandArgs
[Nouveau 0.9.8j]
PostBuildCommand can be used to specify an external application to modify the gcode produced from the post processor.
PostBuildCommandArgs contains any arguments to pass to the application.
The following macros are recognised: {$outfile} is the filename of the raw gcode output.
{$cbfile.name} is the short name of the current CamBam document.
Note: Double quotes should be used in command arguments to avoid problems with spaces in filenames.
Exemple:
PostBuildCommand=C:\bin\gcodelinenums.exe
PostBuildCommandArgs="{$outfile}" "{$outfile}.out"
Les macros du post processeur
|
$blocks
|
Cette macro est générée en interne et contient toutes les instructions de déplacement requises par l'Opération d'Usinage actuelle (MOP).
|
|
$comment
|
Insère le texte définit dans la section Commentdu fichier .cbpp.
|
|
$cbfile.footer
|
Insères les options définies dans la propriété CustomFileFooter du dossier d'Usinage du projet (Machining).
|
|
$cbfile.header
|
Insères les options définies dans la propriété CustomFileHeader du dossier d'Usinage du projet (Machining).
|
|
$cbfile.name
|
Insères le nom défini dans la propriété Name du dossier racine du projet.
|
|
$check(x,y,z)
|
Générée en interne, cette macro vérifie les paramètres des coordonnées x, y, z en fonction de l'emplacement actuel de l'outil. Si différentes une séquence de mouvements sera insérée pour se déplacer à la nouvelle position en passant par le ClearancePlane et en utilisant la vitesse de plongée si nécessaire.
|
|
$clearance
|
Mouvement rapide (G0) jusqu'au ClearancePlane (Plan de dégagement)
|
|
$cuttercomp(off|L|R)
|
Compensation du rayon d'outil. Note: Pour l'instant, CamBam ne calcul pas la compensation du rayon d'outil.
off (désactivée) = G40
L (gauche) = G41
R (droite) = G42
|
|
$date
|
Insère la date courante.
|
|
$distancemode
|
Toujours égale à G90 pour l'instant
|
|
$endcomment
|
Insère le texte définit dans la section EndComment du fichier .cbpp.
|
|
$endrewind
|
Codé en hard dans le programme = M30.
|
|
$footer
|
Evalue le texte placé dans la section Footer du fichier .cbpp
|
$g0, $g1, $g2, $g3, $g81, $g82, $g83
$_g0, $_g1, $_g2, $_g3, $_g81, $_g82, $_g83
|
Ces macros contrôlent la façon dont le Gcode est formaté. Le format de chaque code est tiré de la définition G... du fichier .cbpp. Cela peut être utile pour contrôler le remplissage de zéros (par exemple: G1 au lieu deG01), ou pour utiliser d'autres codes G.
Si le préfixe trait de soulignement ( _ )est utilisé, ces instructions sont supposées être modales (persistantes). Du code sera écrit pour la première occurrence, mais omis pour les blocs suivants s'ils utilisent la même instruction.
|
|
$header
|
Evalue le texte placé dans la section Header du fichier .cbpp
|
|
$mop.footer
|
Insères les options définies dans la propriété CustomMOPFooter de l'Opération d'Usinage courante.
|
|
$mop.header
|
Insères les options définies dans la propriété CustomMOPHeader de l'Opération d'Usinage courante.
|
|
$mop.name
|
Insères le contenu de la propriété Name de l'Opération d'Usinage courante.
|
|
$mops
|
Insère une liste d'objets, une entrée par Opération d'Usinage (MOP) active. Chaque entrée de la liste est formatée en utilisant les définitions de la section MOP du fichier .cbpp
|
|
$repeat
|
Codé en hard dans le programme = M47
|
|
$s
|
Insères les options définies dans la propriété SpindleSpeed de l'Opération d'Usinage courante.(Vitesse de broche)
|
|
$spindle
|
Insère une macro dépendant de la valeur de la propriété SpindleDirection de l'Opération d'Usinage courante.(sens de rotation) Sens horaire (cw) = M3 , Sens anti-horaire (ccw) = M4 , Arrêt (off) = M5
|
|
$spindle(off|cw|ccw)
|
Sens horaire (cw) = M3 , Sens anti-horaire (ccw) = M4 , Arrêt (off) = M5
|
|
$stop
|
Codé en hard dans le programme = M0
|
|
$tool.diameter
|
Insères les options définies dans la propriété ToolDiameter de l'Opération d'Usinage courante. (Ø outil)
|
|
$tool.index
|
Insères les options définies dans la propriété ToolNumber de l'Opération d'Usinage courante. (n° d'outil)
|
|
$tool.radius
|
Utilise la propriété ToolProfile pour déterminer le rayon de l'outil. 0 pour une fraise cylindrique, D/2 pour une fraise à bout rond.
|
|
$tool.length
|
à 0 pour l'instant. Prévu pour une gestion de base de donnée d'outils.
|
|
$toolchange
|
Insère une instruction de changement d'outil basée sur la définition ToolChange du fichier .cbpp
Si le n° d'outil n'a pas changé, aucun code n'est inséré.
|
|
$toolchange(first)
|
Insère une instruction de changement d'outil utilisant le premier outil de la liste d'outil du projet courant.
|
|
$tooltable
|
Insère une liste de tous les outils utilisés dans le projet courant. Chaque entrée est formatée en utilisant la définition ToolTableItem du fichier .cbpp
|
|
$units
|
Utilise la propriété Units du projet. mm = G21, pouces = G20
|
|
$velocitymode
|
Insères l'option définie dans la propriété VelocityMode de l'Opération d'Usinage courante.
Parcours exact = G61 , Vitesse constante = G64
|
|
$workplane
|
Insères l'option définie dans la propriété WorkPlane de l'Opération d'Usinage courante.
XY=G17, XZ=G18, YZ=G19
|
$x, $y, $z, $a, $b, $c, $i, $j, $f, $r, $p, $q
$_x, $_y, $_z, $_a, $_b, $_c, $_i, $_j, $_f, $_r, $_p, $_q
|
Ces macros insèrent les paramètres utilisés dans les commandes de déplacement courantes du Gcode.
Si le préfixe trait de soulignement ( _ )est utilisé, ces instructions sont supposées être modales (persistantes). Cela signifie qu'ils ne seront écrits dans le code uniquement si la valeur courante à changée. Omettre le ( _ ) force leur écriture.
|
$xneg, $yneg, $zneg, ...
[Nouveau 0.9.8h]
|
Même chose que les macros $x, $_y etc, mais avec inversion du signe.
|
$xabs, $yabs, $zabs, ...
[Nouveau 0.9.8h]
|
Même chose que les macros $x, $_y etc, mais toujours positive (valeur absolue).
|