Si vous souhaitez utiliser la version git d’EMC2, veuillez suivre les instructions de notre wiki pour obtenir le code source:: http://wiki.linuxcnc.org/cgi-bin/emcinfo.pl?Git

Une ligne de commentaires débute avec un ; ou un #. Si le logiciel qui analyse le fichier ini rencontre l’un ou l’autre de ces caractères, le reste de la ligne est ignorée. Les commentaires peuvent être utilisés pour décrire ce que font les éléments du fichier INI.

; Ceci est le fichier de configuration de ma petite fraiseuse.

Des commentaires peuvent également être utilisés pour choisir entre plusieurs valeurs d’une seule variable.

# DISPLAY = tkemc

Dans cette liste, la variable DISPLAY est positionnée sur axis puisque toutes les autres sont commentées. Si quelqu’un édite une liste comme celle-ci et par erreur, décommente deux lignes, c’est la première rencontrée qui sera utilisée.

Notez que dans une ligne de variables, les caractères `#” et ` `;`” n’indiquent pas un commentaire.

INCORRECT = value     # and a comment

Les différentes parties d’un fichier .ini sont regroupées dans des sections. Une section commence par son nom en majuscules entre crochets [UNE_SECTION]. L’ordre des sections est sans importance. Les sections suivantes sont utilisées par emc:

Une ligne de variables est composée d’un nom de variable, du signe égal (=) et d’une valeur. Tout, du premier caractère non blanc qui suit le signe = jusqu'à la fin de la ligne, est passé comme valeur à la variable. Vous pouvez donc intercaler des espaces entre les symboles si besoin. Un nom de variable est souvent appelé un mot clé.

Les paragraphes suivants détaillent chaque section du fichier de configuration, en utilisant des exemples de variables dans les lignes de configuration.

Certaines de ces variables sont utilisées par EMC. Elles doivent toujours utiliser le nom de section et le nom de variable dans leur appellation. D’autres variables ne sont utilisées que par HAL. Les noms des sections et les noms des variables indiquées sont celles qui sont utilisées dans les exemples de fichiers de configuration.

Les différentes interfaces du programme utilisent différentes options. Toutes les options ne sont pas supportées par toutes les interfaces.

DISPLAY = tkemc Le nom de l’interface utilisateur à utiliser. Les options disponibles sont les suivantes:

La section [TRAJ] contient les paramètres généraux du module planificateur de trajectoires d' EMCMOT. Vous n’aurez pas à modifier ces valeurs si vous utilisez EMC avec une machine à trois axes en provenance des USA. Si vous êtes dans une zone métrique, utilisant des éléments matériels métriques, vous pourrez utiliser le fichier stepper_mm.ini dans lequel les valeurs sont déjà configurées dans cette unité.

Attention : NO_FORCE_HOMING mise à 1 permettra à la machine de franchir les limites logicielles pendant les mouvements ce qui n’est pas souhaîtable pour un fonctionnement normal!

Les sections [AXIS_0], [AXIS_1], etc. contiennent les paramètres généraux des composants individuels du module de contrôle. La numérotation des sections axis commencent à 0 et vont jusqu’au nombre d’axes spécifié dans la variable [TRAJ] AXES, moins 1.

La position nominale est celle où devrait être le mobile. La position en marche positive signifie, où se trouve le mobile pendant le déplacement dans le sens positif. La position en marche négative signifie, où se trouve le mobile pendant le déplacement dans le sens négatif. Un triplet par ligne. Actuellement la limite d’EMC2 est de 256 triplets par axe. Si COMP_FILE est spécifié, BACKLASH est ignoré. Les valeurs sont en unités machine.

Exemple de triplet avec COMP_FILE_TYPE = 0: 1.00 1.01 0.99.

Le même exemple de triplet avec COMP_FILE_TYPE = 1: 1.00 -0.01 0.01

La figure [fig: Sequences de prise d-origine] montre les quatre séquences de prise d’origine possibles, avec les variables de configuration associées [cap:Variables sequences de POM]. Une description détaillée de ces paramètres sera faite au chapitre suivant.

[fig: Sequences de prise d-origine]

Les séquences de POM possibles

Il y a six combinaisons possibles des variables qui définissent le déroulement de la séquence de prise d’origine. EIles sont définies dans la section [AXIS] du fichier ini.

Quand l’interpréteur d’EMC à été créé, il à été écrit pour les fraiseuses. C’est pourquoi le plan par défaut est le plan XY (G17). Sur un tour standard utilise seulement les axes du plan XZ (G18). Pour changer le plan par défaut d’un tour, mettez la ligne suivante dans la section RS274NGC du fichier ini.

RS274NGC_STARTUP_CODE = G18

Beaucoup de ces paramètres servent d’aide au déboguage et sont sujets aux changements ou au retrait à tout moment.

motion-command-handler.time (s32, RO)

motion-command-handler.tmax (s32, RW)

motion-controller.time (s32, RO)

motion-controller.tmax (s32, RW)

Généralement, ces fonctions sont toutes les deux ajoutées à servo-thread dans l’ordre suivant:

Beaucoup de ces paramètres servent d’aide au déboguage et sont sujets aux changements ou au retrait à tout moment.

La commande "loadrt" charge un composant temps réel de HAL. Les composants temps réel doivent être ajoutés au thread temps réel pour être fonctionnels. Il n’est pas possible de charger un composant de l’espace utilisateur dans l’espace temps réel.

Syntaxe et exemple:

*loadrt <composant> <options>*

*loadrt mux4 count=1*

La commande "addf" ajoute une fonction à un thread temps réel. Si l’assistant StepConf a été utilisé pour créer la configuration, deux threads ont été créés.

Syntaxe et exemple:

*addf <composant> <thread>*

*addf mux4 servo-thread*

La commande "loadusr" charge un composant de HAL de l’espace utilisateur. Les programmes de l’espace utilisateur ont leur propre process séparé qui optionellement communique avec les autres composants de HAL via leurs pins et paramètres. Il n’est pas possible de charger un composant temps réel dans l’espace utilisateur.

Les drapeaux peuvent être un ou plusieurs parmis les suivants:

Syntaxe et exemple:

*loadusr <composant> <options>*

*loadusr halui*

*loadusr -Wn spindle gs2_vfd -n spindle*

 En anglais ça donne "loadusr wait for name spindle component gs2_vfd
name spindle." +
 Le -n spindle est une partie du composant gs2_vfd et non de la
commande loadusr.

La commande "net" crée une "connection" entre un signal et une ou plusieurs pins. Les indicateurs de direction "⇐ et ⇒" sont seulement des aides à la lecture, ils n’ont pas d’autre utilité.

Syntaxe et exemple:

*net <signal-name> <pin-name> <opt-direction> <opt-pin-name>*

*net both-home-y <= parport.0.pin-11-in*

Chaque signal ne peut avoir qu’une seule source (une seule pin de HAL "out”) et autant de «lecteurs» (des pins de HAL "in") que souhaité. Dans la colonne Dir de la fenêtre de configuration de HAL il est possible de voir quelles pins sont "in" et quelles pins sont "out".

Pour faire celà en une ligne:

*net xStep stepgen.0.out => parport.0.pin-02-out parport.0.pin-08-out*

Ou pour le faire en plusieurs lignes, utiliser simplement le signal avec les lecteurs des lignes suivantes:

*net xStep stepgen.0.out => parport.0.pin-02-out +
net xStep => parport.0.pin-02-out*

Les pins appelées I/O pins comme «index-enable», ne suivent pas cette règle.

La commande "setp" ajuste la valeur d’une pin ou d’un paramètre. Les valeurs valides dépendront du type de la pin ou du paramètre.

Pour des informations sur les flottants voir ici (en anglais):

http://en.wikipedia.org/wiki/Floating_point

Les paramètres peuvent être positionnés avant utilisation ou pendant l’utilisation, toutefois certains composants ont des paramètres qui doivent être positionnés avant utilisation. Il n’est pas possible d’utiliser «setp» sur une pin connectée à un signal.

Syntaxe et exemple:

*setp <pin/parameter-name> <value>*

*setp paraport.0.pin-08-out TRUE*

Le composant "and2" est une porte "and" à deux entrées. Sa table de vérité montre la sortie pour chaque combinaison des entrées.

Syntaxe

*and2 [count=N|names=name1[,name2...]]*

Fonctions

and2.n

Pins

and2.N.in0 (bit, in) +
and2.N.in1 (bit, in) +
and2.N.out (bit, out)

Table de vérité

Le composant "not" est un simple inverseur d'état.

Syntaxe

*not [count=n|names=name1[,name2...]]*

Fonctions

not.all +
not.n

Pins

not.n.in (bit, in) +
not.n.out (bit, out)

Table de vérité

Le composant "or2" est une porte OR à deux entrées.

Syntaxe

*or2[count=,|names=name1[,name2...]]*

Fonctions

or2.n

Pins

or2.n.in0 (bit, in) +
or2.n.in1 (bit, in) +
or2.n.out (bit, out)

Table de vérité

Le composant "xor2" est une porte XOR à deux entrées (OU exclusif).

Syntaxe

*xor2[count=,|names=name1[,name2...]]*

Fonctions

xor2.n

Pins

xor2.n.in0 (bit, in) +
xor2.n.in1 (bit, in) +
xor2.n.out (bit, out)

Table de vérité

Un exemple de connection avec un "and2", deux entrées vers une sortie.

*loadrt and2 count=1 +
addf and2.0 servo-thread +
net my-sigin1 and2.0.in0 <= parport.0.pin-11-in +
net my-sigin2 and2.0.in.1 <= parport.0.pin-12-in +
net both-on parport.0.pin-14-out <= and2.0.out*

Dans cet exemple un and2 est chargé dans l’espace temps réel, puis ajouté à servo thread. Ensuite la broche d’entrée 11 du port parallèle est connectée à l’entrée in0 de la porte. Puis la broche d’entrée 12 du port est connectée à l’entrée in1 de la porte. Enfin la sortie and2.0.out de la porte est connectée à la broche de sortie 14 du port parallèle. Ainsi en suivant la table de vérité du and2, si les broches 11 et 12 du port sont à 1, alors sa sortie 14 est à 1 aussi.

La gauche de l'écran que montre la figure  [cap:-Fentre-Halshow] est une arborescence, un peu comme vous pouvez le voir avec certains navigateurs de fichiers. Sur la droite, une zone avec deux onglets: MONTRER et WATCH.

Figure 7.2. Ecran de Halshow

L’arborescence montre toutes les parties principales de HAL. En face de chacune d’entre elles, se trouve un petit signe + ou - dans une case. Cliquer sur le signe plus pour déployer cette partie de l’arborescence et affichera son contenu. Si cette case affiche un signe moins, cliquer dessus repliera cette section de l’arborescence.

Il est également possible de déployer et de replier l’arborescence complète depuis le menu “Arborescence”.

Figure 7.3. L’onglet Montrer

En cliquant sur un nom dans l’arborescence plutôt que sur son signe plus ou moins, par exemple le mot “Components”, HAL affichera tout ce qu’il connait du contenu de celui-ci. La figure  [cap:-Fentre-Halshow] montre une liste comme celle que vous verrez si vous cliquez sur “Components” avec une carte servo standard m5i20 en fonctionnement. L’affichage des informations est exactement le même que celui des traditionnels outils d’analyse de HAL en mode texte. L’avantage ici, c’est que nous y avons accès d’un clic de souris. Accès qui peut être aussi large ou aussi focalisé que vous le voulez.

Si nous examinons de plus près l’affichage de l’arborescence, nous pouvons voir que les six éléments principaux peuvent tous être déployés d’au moins un niveau. Quand ces niveaux sont à leur tour déployés vous obtenez une information de plus en plus focalisée en cliquant sur le nom des éléments dans l’arborescence. Vous trouverez que certaines hal pins et certains paramètres affichent plusieurs réponses. C’est dû à la nature des routines de recherche dans halcmd lui même. Si vous cherchez une pin, vous pouvez en trouver deux comme cela:

Component Pins:

Le deuxième nom de pin contient le nom complémenté du premier.

Dans le bas de l’onglet Montrer, un champ de saisie permet de jouer sur le fonctionnement de HAL. Les commandes que vous entrez ici et leur effet sur HAL, ne sont pas enregistrés. Elles persisteront tant qu’EMC tournera, mais disparaîtront dès son arrêt.

Le champ de saisie marqué “Tester une commande HAL:” acceptera n’importe quelle commande valide pour halcmd. Elles incluent:

Ce petit éditeur entrera une commande à chaque fois que vous presserez <Entrée> ou que vous cliquerez sur le bouton “Exécuter”. Si une commande y est mal formée, un dialogue d’erreur s’affichera. Si vous n'êtes pas sûr de savoir comment formuler une commande, vous trouverez la réponse dans la documentation de halcmd et des modules spécifiques avec lesquels vous travaillez.

Nous allons utiliser cet éditeur pour ajouter un module différentiel à HAL et le connecter à la position d’un axe pour voir le ratio de changement de position, par exemple, l’accélération. Il faut d’abord charger un module de HAL nommé blocks, l’ajouter au thread servo et le connectet à la pin position d’un axe. Une fois cela fait, nous pourrons retrouver la sortie du différentiateur dans halscope. Alors allons-y. (oui j’ai vérifié).

Ndt: le message qui s’affiche au chargement de blocks ne l’empêche pas de fonctionner.

loadrt blocks ddt=1

Maintenant, regardez dans components, vous devriez y voir blocks.

Loaded HAL Components:

Effectivement, il est là. Dans notre cas l’id est 08. Ensuite nous devons savoir quelles fonctions sont disponibles avec lui, nous regardons dans Functions.

Exported Functions:

Ici, nous cherchons owner #08 et voyons que blocks a exporté une fonction nommée ddt.0. Nous devrions être en mesure d’ajouter ddt.0 au thread servo et il fera ses calculs chaque fois que le thread sera mis à jour. Encore une fois recherchons la commande addf et on voit qu’elle utilise trois arguments comme cela:

addf <functname> <threadname> [<position>]

Nous connaissons déjà functname=ddt.0, pour trouver le nom du thread, déployons l’arborescence des Threads. Nous y trouvons deux threads, servo-thread et base-thread. La position de ddt.0 dans le thread n’est pas critique. Passons la commande:

addf ddt.0 servo-thread

Comme c’est juste pour visualiser, nous laissons la position en blanc pour obtenir la dernière position dans le thread. La figure  [cap:-Commande-addf] montre l'état de halshow après que cette commande a été exécutée.

Figure 7.4. Commande Addf

Ensuite, nous devons connecter ce block à quelque chose. Mais comment savoir quelles pins sont disponibles? La réponse se trouve dans l’arbre, en regardant sous Pins. On y trouve ddt et on voit:

Component Pins:

Cela semble assez facile à comprendre, mais à quel signal ou pin voulons-nous nous connecter, ça pourrait être une pin d’axe, une pin de stepgen, ou un signal. On vois cela en regardant dans axis.0.

Component Pins:

Donc, il semble que Xpos-cmd devrait être un bon signal à utiliser. Retour à l'éditeur et entrons la commande suivante:

linksp Xpos-cmd ddt.0.in

Maintenant si on regarde le signal Xpos-cmd dans l’arbre, on voit ce qu’on a fait.

Signals:

Nous voyons que ce signal provient de axis.0.motor-pos-cmd et va, à la fois, sur ddt.0.in et sur stepgen.0.position-cmd. En connectant notre block au signal nous avons évité les complications avec le flux normal de cette commande de mouvement.

La zone de l’onglet “Montrer” utilise halcmd pour découvrir ce qui se passe à l’intérieur de HAL pendant son fonctionnement. Il vous donne une information complète de ce qu’il découvre. Il met aussi à jour dès qu’une commande est envoyée depuis le petit éditeur pour modifier ce HAL. Il arrive un temps ou vous voulez autre chose d’affiché, sans la totalité des informations disponibles dans cette zone. C’est la grande valeur de l’onglet WATCH d’offrir cela.

En cliquant sur l’onglet WATCH une zone vide s’affichera. Vous pouvez ajouter des signaux et des pins dans cette zone et visualiser leurs valeurs.^[9] Vous pouvez ajouter des pins ou des signaux quand l’onglet Watch est ouvert, en cliquant sur leurs noms. La figure [cap:-L-onglet-Watch] Montre cette zone avec plusieurs signaux de type “bit”. Parmis ces signaux, les enable-out pour les trois premiers axes et deux de la branche iocontrol, les signaux “estop”. Notez que les axes ne sont pas activés même si les signaux estop disent qu’EMC n’est pas en estop. Un bref regard sur themc en arrière plan, montre que l'état d’EMC est ESTOP RESET. L’activation des amplis ne deviendra pas vraie tant que la machine ne sera pas mise en marche.

Figure 7.5. L’onglet Watch

Les cercles de deux couleurs, simili leds, sont toujours bruns foncé quand un signal est faux. Elle sont jaunes quand le signal est vrai. Quand une pin ou un signal est sélectionné mais n’est pas de type bit, sa valeur numérique s’affiche.

Watch permet de visualiser rapidement le résultat de tests sur des contacts ou de voir l’effet d’un changement que vous faites dans EMC en utilisant l’interface graphique. Le taux de rafraîchissement de Watch est un peu trop lent pour visualiser les impulsions de pas d’un moteur mais vous pouvez l’utiliser si vous déplacez un axe très lentement ou par très petits incréments de distance. Si vous avez déjà utilisé IO_Show dans EMC, la page de Watch de halshow peut être réglée pour afficher ce que fait le port parallèle.

Ce fichier contient certaines commandes de HAL et habituellement ressemble à celà:

# standard pinout config file for 3-axis steppers
# using a parport for I/O
#
# first load the parport driver
loadrt hal_parport cfg="0x0378"
#
# next connect the parport functions to threads
# read inputs first
addf parport.0.read base-thread 1
# write outputs last
addf parport.0.write base-thread -1
#
# finally connect physical pins to the signals
net Xstep => parport.0.pin-03-out
net Xdir  => parport.0.pin-02-out
net Ystep => parport.0.pin-05-out
net Ydir  => parport.0.pin-04-out
net Zstep => parport.0.pin-07-out
net Zdir  => parport.0.pin-06-out

# create a signal for the estop loopback
net estop-loop iocontrol.0.user-enable-out iocontrol.0.emc-enable-in

# create signals for tool loading loopback
net tool-prep-loop iocontrol.0.tool-prepare iocontrol.0.tool-prepared
net tool-change-loop iocontrol.0.tool-change iocontrol.0.tool-changed

# connect "spindle on" motion controller pin to a physical pin
net spindle-on motion.spindle-on => parport.0.pin-09-out

###
### You might use something like this to enable chopper drives when machine ON
### the Xen signal is defined in core_stepper.hal
###

# net Xen => parport.0.pin-01-out

###
### If you want active low for this pin, invert it like this:
###

# setp parport.0.pin-01-out-invert 1

###
### A sample home switch on the X axis (axis 0).  make a signal,
### link the incoming parport pin to the signal, then link the signal
### to EMC's axis 0 home switch input pin
###

# net Xhome parport.0.pin-10-in => axis.0.home-sw-in

###
### Shared home switches all on one parallel port pin?
### that's ok, hook the same signal to all the axes, but be sure to
### set HOME_IS_SHARED and HOME_SEQUENCE in the ini file.  See the
### user manual!
###

# net homeswitches <= parport.0.pin-10-in
# net homeswitches => axis.0.home-sw-in
# net homeswitches => axis.1.home-sw-in
# net homeswitches => axis.2.home-sw-in

###
### Sample separate limit switches on the X axis (axis 0)
###

# net X-neg-limit parport.0.pin-11-in => axis.0.neg-lim-sw-in
# net X-pos-limit parport.0.pin-12-in => axis.0.pos-lim-sw-in

###
### Just like the shared home switches example, you can wire together
### limit switches.  Beware if you hit one, EMC will stop but can't tell
### you which switch/axis has faulted.  Use caution when recovering from this.
###

# net Xlimits parport.0.pin-13-in => axis.0.neg-lim-sw-in axis.0.pos-lim-sw-in

Les lignes commençant par # sont des commentaires, aidant à la lecture du fichier.

Voici les opérations qui sont exécutées quand le fichier standard_pinout.hal est lu par l’interpréteur:

Pour modifier le fichier standard_pinout.hal, il suffit de l’ouvrir dans un éditeur de texte puis d’y localiser les parties à modifier.

Si vous voulez par exemple, modifier les broches de pas et de direction de l’axe X, il vous suffit de modifier le numéro de la variable nommée parport.0.pin-XX-out:

linksp Xstep parport.0.pin-03-out

peut être modifiée pour devenir:

linksp Xstep parport.0.pin-02-out

ou de manière générale n’importe quel numéro que vous souaîteriez.

Attention: il faut être certain de n’avoir qu’un seul signal connecté à une broche.

Si une interface attends un signal “actif bas”, ajouter une ligne avec le paramètre d’inversion de la sortie, -invert. Par exemple, pour inverser le signal de rotation de la broche:

setp parport.0.pin-09-invert TRUE

Si votre vitesse de broche peut être contrôlée par un signal de PWM, utilisez le composant «pwmgen» pour créer ce signal:

loadrt pwmgen output_type=0

Ce qui donnera le fonctionnement suivant, pour un signal PWM à: 0% donnera une vitesse de 0tr/mn, 10% une vitesse de 180tr/mn, etc. Si un signal PWM supérieur à 0% est requis pour que la broche commence à tourner, suivez l’exemple du fichier de configuration nist-lathe qui utilise un composant d'échelle (scale).

Certains pilotes de moteurs requiert un signal de validation «enable» avant d’autoriser tout mouvement du moteur. Pour celà des signaux sont déjà définis et appelés Xen, Yen, Zen.

Pour les connecter vous pouvez utilisez l’exemple suivant:

linksp Xen parport.0.pin-08-out

Il est possible d’avoir une seule pin de validation pour l’ensemble des pilotes, ou plusieurs selon la configuration que vous voulez. Notez toutefois qu’habituellement quand un axe est en défaut, tous les autres sont invalidés aussi de sorte que, n’avoir qu’un seul signal/pin de validation pour l’ensemble est parfaitement sécurisé.

Comme vous pouvez le voir à la section [sub:standard_pinout.hal], par défaut la configuration standard n’utilise pas de bouton d’Arrêt d’Urgence externe. ^[12]

Pour ajouter un simple bouton externe (ou plusieurs en série) vous devez compléter les lignes suivantes:

# create a signal for the estop loopback
net estop-loop iocontrol.0.user-enable-out iocontrol.0.emc-enable-in

avec

net estop-out <= iocontrol.0.user-enable-out
net estop-ext     <= parport.0.pin-01-in
net estop-ext => iocontrol.0.emc-enable-in

Ce qui implique qu’un bouton d’Arrêt d’Urgence soit connecté sur la broche 01 du port parallèle. Tant que le bouton est enfoncé (le contact ouvert)^[13], EMC2 restera dans l'état «Arrêt d’Urgence» (ESTOP). Quand le bouton externe sera relâché, EMC2 passera immédiatement dans l'état «Arrêt d’Urgence Relâché» (ESTOP-RESET) vous pourrez ensuite mettre la machine en marche en pressant le bouton «Marche machine» et vous êtes alors prêt à continuer votre travail avec EMC2.

emc2$

<type-array> est une série d’entiers décimaux séparés par des virgules. Chaque chiffre provoquera le chargement d’un simple générateur d’impulsions de pas, la valeur de ce chiffre déterminera le type de pas. <ctrl_array> est une série de lettres “p`” ou “`v ” séparées par des virgules, qui spécifient le mode pas ou le mode vitesse. ctrl_type est optionnel, si il est omis, tous les générateurs de pas seront en mode position. Par exemple, la commande:

emc2#

va installer trois générateurs de pas. Les deux premiers utilisent le type de pas 0 (pas et direction) et fonctionnent en mode position. Le dernier utilise le type de pas 2 (quadrature) et fonctionne en mode vitesse. La valeur par défaut de <config-array> est “0,0,0” qui va installer trois générateurs de type 0 (step/dir). Le nombre maximum de générateurs de pas est de 8 (comme définit par MAX_CHAN dans stepgen.c). Chaque générateur est indépendant, mais tous sont actualisés par la même fonction(s), au même instant. Dans les descriptions qui suivent, <chan> est le nombre de générateurs spécifiques. La numérotation des générateurs commence à 0.

emc2$

Chaque générateur d’impulsions de pas n’aura que certaines de ces pins, selon le type de pas et le mode de contrôle sélectionné.

En mode position, les valeurs de maxvel et de maxaccel sont utilisées par la boucle de position interne pour éviter de générer des trains d’impulsions de pas que le moteur ne peut pas suivre. Lorsqu’elles sont réglées sur des valeurs appropriées pour le moteur, même un grand changement instantané dans la position commandée produira un mouvement trapézoïdal en douceur vers la nouvelle position. L’algorithme fonctionne en mesurant à la fois, l’erreur de position et l’erreur de vitesse, puis en calculant une accélération qui tende à réduire vers zéro, les deux en même temps. Pour plus de détails, y compris les contenus de la boîte “d'équation de contrôle”, consulter le code source.

En mode vitesse, maxvel est une simple limite qui est appliquée à la vitesse commandée, maxaccel est utilisé pour créer une rampe avec la fréquence actuelle, si la vitesse commandée change brutalement. Comme dans le mode position, des valeurs appropriées de ces paramètres assurent que le moteur pourra suivre le train d’impulsions généré.

Le générateur de pas supporte 15 différentes “séquences de pas”. Le type de pas 0 est le plus familier, c’est le standard pas et direction (step/dir). Quand stepgen est configuré pour le type 0, il y a quatre paramètres supplémentaires qui déterminent le timing exact des signaux de pas et de direction. Voir la figure [fig:StepDir-timing] pour la signification de ces paramètres. Les paramètres sont en nanosecondes, mais ils doivent être arrondis à un entier, multiple de la période du thread qui appelle make_pulses(). Par exemple, si make_pulses() est appelée toutes les 16µs et que “steplen” est à 20000, alors l’impulsion de pas aura une durée de 2 x 16 = 32µs. La valeur par défaut de ces quatre paramètres est de 1ns, mais l’arrondi automatique prendra effet au premier lancement du code. Puisqu’un pas exige d'être haut pendant “steplen”`ns et bas pendant `“stepspace”`ns, la fréquence maximale est 1.000.000.000 divisé par `(steplen+stepspace). Si “maxfreq” est réglé plus haut que cette limite, il sera abaissé automatiquement. Si “maxfreq” est à zéro, il restera à zéro, mais la fréquence de sortie sera toujours limitée.

Timing pas et direction. Le type de pas 1 a deux sorties, up et down. Les impulsions apparaissent sur l’une ou l’autre, selon la direction du déplacement. Chaque impulsion a une durée de “steplen”`ns et les impulsions sont séparées de `“stepspace”`ns. La fréquence maximale est la même que pour le type 0. Si `“maxfreq” est réglé plus haut que cette limite il sera abaissé automatiquement. Si “maxfreq” est à zéro, il restera à zéro, mais la fréquence de sortie sera toujours limitée.

Les séquences 2 jusqu'à 14 sont basées sur les états et ont entre deux et cinq sorties. Pour chaque pas, un compteur d''état est incrémenté ou décrémenté. Les figures [fig:Trois-phases-quadrature], [fig:Quatre-phases] et [fig:Cinq-phases] montrent les différentes séquences des sorties en fonction de l'état du compteur. La fréquence maximale est 1.000.000.000 divisé par “steplen`” et comme dans les autres séquences, `“maxfreq” sera abaissé si il est au dessus de cette limite.

Séquence de pas à cinq phases. Le composant exporte trois fonctions. Chaque fonction agit sur tous les générateurs d’impulsions de pas. Lancer différents générateurs dans différents threads n’est pas supporté.

La fonction à grande vitesse “stepgen.make-pulses” devrait être lancée dans un thread très rapide, entre 10 et 50us selon les capacités de l’ordinateur. C’est la période de ce thread qui détermine la fréquence maximale des pas, de steplen, stepspace, dirsetup, dirhold et dirdelay, tous sont arrondis au multiple entier de la période du thread en nanosecondes. Les deux autres fonctions peuvent être appelées beaucoup plus lentement.

emc2$

<config-array> est une série d’entiers décimaux séparés par des virgules. Chaque chiffre provoquera le chargement d’un simple générateur de PWM, la valeur de ce chiffre determinera le type de sortie. Par exemple:

emc2$

va installer trois générateurs de PWM. Le premier utilisera une sortie de type 0 (PWM seule), le suivant utilisera une sortie de type 1 (PWM et direction) et le troisième utilisera une sortie de type 2 (UP et DOWN). Il n’y a pas de valeur par défaut, si <config-array> n’est pas spécifié, aucun générateur de PWM ne sera installé. Le nombre maximum de générateurs de fréquences est de 8 (comme définit par MAX_CHAN dans pwmgen.c). Chaque générateur est indépendant, mais tous sont mis à jour par la même fonction(s), au même instant. Dans les descriptions qui suivent, <chan> est le nombre de générateurs spécifiques. La numérotation des générateurs de PWM commence à 0.

emc2$

Chaque générateur de PWM aura les pins suivantes:

Chaque générateur de PWM aura également certaines de ces pins, selon le type de sortie choisi:

Le générateur de PWM supporte trois “types de sortie”. Le type 0 a une seule pin de sortie. Seules, les commandes positives sont acceptées, les valeurs négatives sont traitées comme zéro (elle seront affectées par` min-dc` si il est différent de zéro). Le type 1 a deux pins de sortie, une pour le signal PWM/PDM et une pour indiquer la direction. Le rapport cyclique d’une pin PWM est basé sur la valeur absolue de la commande, de sorte que les valeurs négatives sont acceptables. La pin de direction est fausse pour les commandes positives et vraie pour les commandes négatives. Finalement, le type 2 a également deux sorties, appelées “up” et “down”. Pour les commandes positives, le signal PWM apparaît sur la sortie up et la sortie down reste fausse. Pour les commandes négatives, le signal PWM apparaît sur la sortie down et la sortie up reste fausse. Les sorties de type 2 sont appropriées pour piloter la plupart des ponts en H.

Le composant exporte deux fonctions. Chaque fonction agit sur tous les générateurs de PWM, lancer différents générateurs dans différents threads n’est pas supporté.

La fonction haute vitesse “pwmgen.make-pulses” devrait être lancée dans un thread très rapide, entre 10 et 50µs selon les capacités de l’ordinateur. C’est la période de ce thread qui détermine la fréquence maximale de la porteuse PWM, ainsi que la résolution des signaux PWM ou PDM. L’autre fonction peut être appelée beaucoup plus lentement.

Diagramme bloc du compteur de codeur. 

emc2$

<counters> est le nombre de compteurs de codeur à installer. Si numchan n’est pas spécifié, trois compteurs seront installés. Le nombre maximum de compteurs est de 8 (comme définit par MAX_CHAN dans encoder.c). Chaque compteur est indépendant, mais tous sont mis à jour par la même fonction(s) au même instant. Dans les descriptions qui suivent, <chan> est le nombre de compteurs spécifiques. La numérotation des compteurs commence à 0.

emc2$

Le composant exporte deux fonctions. Chaque fonction agit sur tous les compteurs de codeur, lancer différents compteurs de codeur dans différents threads n’est pas supporté.

Diagramme bloc d’une boucle PID. 

emc2$

<loops> est le nombre de boucles PID à installer. Si numchan n’est pas spécifié, une seule boucle sera installée. Le nombre maximum de boucles est de 16 (comme définit par MAX_CHAN dans pid.c). Chaque boucle est complétement indépendante. Dans les descriptions qui suivent, <loopnum> est le nombre de boucles spécifiques. La numérotation des boucle PID commence à 0.

Si debug=1 est spécifié, le composant exporte quelques paramètres destinés au déboguage et aux réglages. Par défaut, ces paramètres ne sont pas exportés, pour économiser la mémoire partagée et éviter d’encombrer la liste des paramètres.

emc2$

Les trois principales pins sont:

Pour une boucle de position, command et feedback sont en unités de longueur. Pour un axe linéaire, cela pourrait être des pouces, mm, mètres, ou tout autre unité pertinente. De même pour un axe angulaire, ils pourraient être des degrés, radians, etc. Les unités sur la pin output représentent l'écart nécessaire pour que la rétroaction coïncide avec la commande. Pour une boucle de position, output est une vitesse exprimée en pouces/seconde, mm/seconde, degrés/seconde, etc. Les unités de temps sont toujours des secondes et les unités de vitesses restent cohérentes avec les unités de longueur. Si la commande et la rétroaction sont en mètres, la sortie sera en mètres par seconde.

Chaque boucle PID a deux autres pins qui sont utilisées pour surveiller ou contrôler le fonctionnement général du composant.

Le gain PID, les limites et autres caractèristiques accordables de la boucle sont implémentés comme des paramètres.

Toutes les limites max???, sont implémentées de sorte que si la valeur de ce paramètre est à zéro, il n’y a pas de limite.

Si debug=1 est spécifié quand le composant est installé, quatre paramètres supplémentaires seront exportés:

Le composant exporte une fonction pour chaque boucle PID. Cette fonction exécute tous les calculs nécessaires à la boucle. Puisque chaque boucle a sa propre fonction, les différentes boucles peuvent être incluses dans les différents threads et exécutées à différents rythmes.

Si vous voulez comprendre exactement l’algorithme utilisé pour calculer la sortie d’une boucle PID, référez vous à la figure [fig:Diagramme-bloc-PID], les commentaires au début du source` emc2/src/hal/components/pid.c` et bien sûr, au code lui même. Les calculs de boucle sont dans la fonction C` calc_pid()`.

emc2$

<number> est le nombre de codeurs à simuler. Si aucun n’est spécifié, un seul codeur sera installé. Le nombre maximum de codeurs est de 8 (comme définit par MAX_CHAN dans sim_encoder.c).

emc2$

Quand .speed est positive, .phase-A mène .phase-B.

Noter que les impulsions par tour ne sont pas identiques aux valeurs de comptage par tour (counts). Une impulsion est un cycle complet de quadrature. La plupart des codeurs comptent quatre fois pendant un cycle complet.

Le composant exporte deux fonctions. Chaque fonction affecte tous les codeurs simulés.

emc2$

<config-string> est une série d’entiers décimaux séparés par des espaces. Chaque chiffre installe un groupe de filtres anti-rebond identiques, le chiffre détermine le nombre de filtres dans le groupe. Par exemple:

emc2$

va installer trois groupes de filtres. Le groupe 0 contient un filtre, le groupe 1 en contient quatre et le groupe 2 en contient deux. La valeur par défaut de <config-string> est “1” qui installe un seul groupe contenant un seul filtre. Le nombre maximum de groupes est de 8 (comme définit par MAX_GROUPS dans debounce.c). Le nombre maximum de filtres dans un groupe est limité seulement par l’espace de la mémoire partagée. Chaque groupe est complétement indépendant. Tous les filtres dans un même groupe sont identiques et ils sont tous mis à jour par la même fonction, au même instant. Dans les descriptions qui suivent, <G> est le numéro du groupe et <F> est le numéro du filtre dans le groupe. Le premier filtre est le filtre 0 dans le groupe 0.

emc2$

Chaque filtre individuel a deux pins.

Chaque groupe de filtre a un paramètre^[15].

Le délai du filtre est dans l’unité de la période du thread. Le délai minimum est de zéro. La sortie d’un filtre avec un délai de zéro, suit exactement son entrée, il ne filtre rien. Plus le délai augmente, plus larges seront les impulsions rejetées. Si le délai est de 4, toutes les impulsions égales ou inférieures à quatre périodes du thread, seront rejetées.

Chaque groupe de filtres exporte une fonction qui met à jour tous les filtres de ce groupe “simultanément”. Différents groupes de filtres peuvent être mis à jour dans différents threads et à différentes périodes.

emc2$

<chans> est le nombre de générateurs de signaux à installer. Si numchan n’est pas spécifié, un seul générateur de signaux sera installé. Le nombre maximum de générateurs est de 16 (comme définit par MAX_CHAN dans siggen.c). Chaque générateur est complétement indépendant. Dans les descriptions qui suivent, <chan> est le numéro d’un générateur spécifique. Les numéros de générateur commencent à 0.

emc2$

Chaque générateur a cinq pins de sortie.

Les cinq sorties ont les mêmes fréquence, amplitude et offset.

Trois pins de contrôle s’ajoutent aux pins de sortie:

Par exemple, si siggen.0.amplitude est à 1.0 et siggen.0.offset est à 0.0, les sorties oscilleront entre -1.0 et +1.0. Si siggen.0.amplitude est à 2.5 et siggen.0.offset est à 10.0, les sorties oscilleront entre 7.5 et 12.5.

Aucun. ^[16]

loadrt hal_parport cfg="<config-string>"

La chaine config-string représente l’adresse hexadécimale du port, suivie optionnellement par une direction, le tout répété pour chaque port. Les directions sont “in”, “out”, ou “x”, elles déterminent la direction des broches physiques 2 à 9 et s’il y a lieu de créer des pins d’entrée de HAL pour les broches de contrôle physiques. Si la direction n’est pas précisée, le groupe données sera par défault en sortie. Par exemple:

loadrt hal_parport cfg="0x278 0x378 in 0x20A0 out"

Cet exemple installe les pilotes pour un port 0x0278, avec les broches 2 à 9 en sorties (par défaut, puisque ni “ in ”, ni “out” n’est spécifié), un port 0x0378, avec les broches 2 à 9 en entrées et un port 0x20A0, avec les broches 2 à 9 explicitement spécifiées en sorties. Notez que vous devez connaître l’adresse de base des ports parallèles pour configurer correctement les pilotes. Pour les ports sur bus ISA, ce n’est généralement pas un problème, étant donné que les ports sont presque toujours à une adresse “bien connue”, comme 0x278 ou 0x378 qui sont typiquement configurées dans le BIOS. Les adresses des cartes sur bus PCI sont habituellement trouvées avec “lspci -v” dans une ligne “I/O ports”, ou dans un message du kernel après l’exécution de “sudo modprobe -a parport_pc`”. Il n'y a pas d'adresse par défaut, si `<config-string> ne contient pas au moins une adresse, un message d’erreur s’affichera.

Pour chaque pin, <portnum> est le numéro du port et <pinnum> est le numéro de la broche physique du connecteur DB-25.

Pour chaque broche de sortie physique, le pilote crée une simple pin de HAL, par exemple parport.0.pin-14-out . Les pins 2 jusqu'à 9 font partie du groupe données, elles sont des pins de sortie si le port est défini comme un port de sorties (par défaut en sortie). Les broches 1, 14, 16 et 17 sont des sorties dans tous les modes. Ces pins de HAL contrôlent l'état des pins physiques correspondantes.

Pour chaque pin d’entrée physique, le pilote crée deux pins de HAL, par exemple parport.0.pin-12-in et parport.0.pin-12-in-not . Les pins 10, 11, 12, 13 et 15 sont toujours des sorties. Les pins 2 jusqu'à 9 sont des pins d’entrée seulement si le port est défini comme un port d’entrées. Une pin de HAL -in est VRAIE si la pin physique est haute et FAUSSE si la pin physique est basse. Une pin de HAL -in-not est inversée, elle est FAUSSE si la pin physique est haute. En connectant un signal à l’une ou à l’autre, l’utilisateur peut décider de la logique de l’entrée. En mode “x”, les pins 1, 14, 16 et 17 sont également des pins d’entrée.

Le paramètre -invert détermine si une pin de sortie est active haute ou active basse. Si -invert est FAUX, mettre la pin HAL -out VRAIE placera la pin physique à l'état haut et mettre la pin HAL FAUSSE placera la pin physique à l'état bas. Si -invert est VRAI, mettre la pin HAL -out VRAIE va mettre la pin physique à l'état bas.

Si -reset est VRAI, la fonction de réinitialisation va passer la pin à la valeur de -out-invert. Ceci peut être utilisé en conjonction avec “stepgen doublefreq” pour produire un pas par période.

Les différentes fonctions sont prévues pour les situations où un port doit être mis à jour dans un thread très rapide, mais d’autres ports peuvent être mis à jour dans un thread plus lent pour gagner du temps CPU. Ce n’est probablement pas une bonne idée d’utiliser en même temps, les fonctions -all et une fonction individuelle.

Si le chargement du module le message suivant:

insmod: error inserting '/home/jepler/emc2/rtlib/hal_parport.ko':

s’assurer que le noyau du kernel standard, parport_pc, n’est pas chargé^[17] et qu’aucun périphérique dans le système ne revendique les ports concernés.

SI le module est chargé mais ne semble pas fonctionner, l’adresse du port est incorrecte ou le module probe_parport est requis.

loadrt probe_parport

Si le kernel Linux affiche un message similaire à:

parport: PnPBIOS parport detected.

Quand le module parport_pc est chargé, avec la commande: sudo modprobe -a parport_pc; sudo rmmod parport_pc, l’utilisation de ce module sera probablement nécessaire.

.

Les modules commerciaux ci-dessous pouront êtres traduits en français sur demande.

The commercial modules below could be translated into French on request.

.

loadrt hal_ax5214h cfg="<config-string>"

The config string consists of a hex port address, followed by an 8 character string of “I” and “O” which sets groups of pins as inputs and outputs. The first two character set the direction of the first two 8 bit blocks of pins (0-7 and 8-15). The next two set blocks of 4 pins (16-19 and 20-23). The pattern then repeats, two more blocks of 8 bits (24-31 and 32-39) and two blocks of 4 bits (40-43 and 44-47). If more than one board is installed, the data for the second board follows the first. As an example, the string "0x220 IIIOIIOO 0x300 OIOOIOIO" installs drivers for two boards. The first board is at address 0x220, and has 36 inputs (0-19 and 24-39) and 12 outputs (20-23 and 40-47). The second board is at address 0x300, and has 20 inputs (8-15, 24-31, and 40-43) and 28 outputs (0-7. 16-23, 32-39, and 44-47). Up to 8 boards may be used in one system.

For each pin, <boardnum> is the board number (starts at zero), and <pinnum> is the I/O channel number (0 to 47).

Note that the driver assumes active LOW signals. This is so that modules such as OPTO-22 will work correctly (TRUE means output ON, or input energized). If the signals are being used directly without buffering or isolation the inversion needs to be accounted for. The in- HAL pin is TRUE if the physical pin is low (OPTO-22 module energized), and FALSE if the physical pin is high (OPTO-22 module off). The in-<pinnum>-not HAL pin is inverted — it is FALSE if the physical pin is low (OPTO-22 module energized). By connecting a signal to one or the other, the user can determine the state of the input.

The -invert parameter determines whether an output pin is active high or active low. If -invert is FALSE, setting the HAL out- pin TRUE drives the physical pin low, turning ON an attached OPTO-22 module, and FALSE drives it high, turning OFF the OPTO-22 module. If -invert is TRUE, then setting the HAL out- pin TRUE will drive the physical pin high and turn the module OFF.

loadrt hal_stg [base=<address>] [num_chan=<nr>] [dio="<dio-string>"] [model=<model>]

The base address field is optional; if it’s not provided the driver attempts to autodetect the board. The num_chan field is used to specify the number of channels available on the card, if not used the 8 axis version is assumed. The digital inputs/outputs configuration is determined by a config string passed to insmod when loading the module. The format consists of a four character string that sets the direction of each group of pins. Each character of the direction string is either "I" or "O". The first character sets the direction of port A (Port A - DIO.0-7), the next sets port B (Port B - DIO.8-15), the next sets port C (Port C - DIO.16-23), and the fourth sets port D (Port D - DIO.24-31). The model field can be used in case the driver doesn’t autodetect the right card version^[20]. For example:

loadrt hal_stg base=0x300 num_chan=4 dio="IOIO"

This example installs the stg driver for a card found at the base address of 0x300, 4 channels of encoder feedback, DAC’s and ADC’s, along with 32 bits of I/O configured like this: the first 8 (Port A) configured as Input, the next 8 (Port B) configured as Output, the next 8 (Port C) configured as Input, and the last 8 (Port D) configured as Output

loadrt hal_stg

This example installs the driver and attempts to autodetect the board address and board model, it installs 8 axes by default along with a standard I/O setup: Port A & B configured as Input, Port C & D configured as Output.

For each pin, <channel> is the axis number, and <pinnum> is the logic pin number of the STG^[21].

The in- HAL pin is TRUE if the physical pin is high, and FALSE if the physical pin is low. The in-<pinnum>-not HAL pin is inverted — it is FALSE if the physical pin is high. By connecting a signal to one or the other, the user can determine the state of the input.

The -invert parameter determines whether an output pin is active high or active low. If -invert is FALSE, setting the HAL out- pin TRUE drives the physical pin high, and FALSE drives it low. If -invert is TRUE, then setting the HAL out- pin TRUE will drive the physical pin low.

In the following pins, parameters, and functions, <board> is the board ID. According to the naming conventions the first board should always have an ID of zero, however this driver uses the PCI board ID, so it may be non-zero even if there is only one board.

The Hostmot-4 FPGA configuration has the following pinout. There are three 50-pin ribbon cable connectors on the card: P2, P3, and P4. There are also 8 status LEDs.

In the following pins, parameters, and functions, <board> is the board ID. According to the naming conventions the first board should always have an ID of zero. However this driver sets the ID based on a pair of jumpers on the baord, so it may be non-zero even if there is only one board.

In the following pins, parameters, and functions, <board> is the board ID. According to the naming conventions the first board should always have an ID of zero. However this driver sets the ID based on a pair of jumpers on the baord, so it may be non-zero even if there is only one board.

The src/hal/drivers/pluto_servo_firmware/ and src/hal/drivers/pluto_step_firmware/` ` subdirectories contain the Verilog source code plus additional files used by Quartus for the FPGA firmwares. Altera’s Quartus II software is required to rebuild the FPGA firmware. To rebuild the firmware from the .hdl and other source files, open the .qpf file and press CTRL-L. Then, recompile emc2.

Like the HAL hardware driver, the FPGA firmware is licensed under the terms of the GNU General Public License.

The gratis version of Quartus II runs only on Microsoft Windows, although there is apparently a paid version that runs on Linux.

The Pluto-P board may be ordered from http://www.knjn.com/ShopBoards_Parallel.html (US based, international shipping is available). Some additional information about it is available from http://www.fpga4fun.com/board_pluto-P.html and from the developer’s blog.

A list of all loadrt arguments, HAL function names, pin names and parameter names is in the manual page, pluto_servo.9.

A schematic for a 2A, 2-axis PWM servo amplifier board is available (http://emergent.unpy.net/projects/01148303608). The L298 H-Bridge (L298 H-bridge) is inexpensive and can easily be used for motors up to 4A (one motor per L298) or up to 2A (two motors per L298) with the supply voltage up to 46V. However, the L298 does not have built-in current limiting, a problem for motors with high stall currents. For higher currents and voltages, some users have reported success with International Rectifier’s integrated high-side/low-side drivers. (http://www.cnczone.com/forums/showthread.php?t=25929)

While the “extended main connector” has a superset of signals usually found on a Step & Direction DB25 connector—4 step generators, 9 inputs, and 6 general-purpose outputs—the layout on this header is different than the layout of a standard 26-pin ribbon cable to DB25 connector.

The firmware and driver enforce step length, space, and direction change times. Timings are rounded up to the next multiple of , with a maximum of . The timings are the same as for the software stepgen component, except that “dirhold” and “dirsetup” have been merged into a single parameter “dirtime” which should be the maximum of the two, and that the same step timings are always applied to all channels.

A list of all loadrt arguments, HAL function names, pin names and parameter names is in the manual page, pluto_step.9.

<n> est un nombre compris entre 0 et 7, ou <selected>.

<n> est un nombre compris entre 0 et 7, ou selected.

La vitesse linéaire maximum peut être ajustée entre 0 et la valeur de la variable MAX_VELOCITY dans la section [TRAJ] du fichier ini.

Il arrive que l’utilisateur veuille ajouter des tâches plus complexes devant être effectuées par l’activation d’une pin de HAL. C’est possible en utilisant le schéma de commande en données manuelles (MDI) suivant:

Chaque widget est décrit brièvement, suivi par la forme d'écriture utilisée et d’une capture d'écran. Toutes les balises contenues dans la balise du widget principal, sont optionnelles.

à l’heure actuelle, les deux syntaxes, basée sur les balises et basée sur les attributs, sont supportées. Par exemple, les deux fragments de code XML suivants sont traités de manière identique:

<led halpin="ma-led"/>

et

<led><halpin>"ma-led"</halpin></led>

Quand la syntaxe basée sur les attributs est utilisée, les règles suivantes sont utilisées pour convertir les valeurs des attributs en valeurs Python:

Quand la syntaxe basée sur les balises est utilisée, le texte entre les balises est toujours évalué comme un expression Python.

Les exemples ci-dessous montrent un mélange des deux formats.

Pour ajouter un commentaire utiliser la syntaxe de xml.

<!--Mon commentaire-->

Editer le fichier XML avec un éditeur de texte. La plupart du temps un double click sur le nom de fichier permet de choisir "ouvrir avec l’editeur de texte" ou similaire.

Les couleurs peuvent être spécifiées en utilisant les couleurs RGB de X11 soit par le nom, par exemple: "gray75" ou soit en hexa décimal, par exemple: "#0000ff”. Une liste complète est consultable ici: http://sedition.com/perl/rgb.html.

Couleurs les plus courantes (les numéros suivant la couleur indiquent la nuance de la couleur)

Une LED est utilisée pour indiquer l'état d’un signal BIT. La couleur de la LED sera on_color quand le signal BIT est vrai et off_color autrement.

<led>

<halpin> définit le nom de la pin, par défaut: “led.n”, où n est un entier <size> définit la taille de la led, par défaut: 20 <on_color> définit la couleur de la led LED quand la pin est vraie, par défaut: “green” <off_color> définit la couleur de la LED quand la pin est fausse, par défaut: “ref”

C’est une variante du widget "led".

<vbox> +
<relief>RIDGE</relief> +
<bd>6</bd> +
<rectled> +
<halpin>"ma-led-rect"</halpin> +
<height>"50"</height> +
<width>"100"</width> +
<on_color>"green"</on_color> +
<off_color>"red"</off_color> +
</rectled> +
</vbox>

Le code ci-dessus produit cet exemple. Il affiche également un relief autour de la boîte.

Un bouton permet de contrôler une pin BIT. La pin sera mise vraie quand le bouton sera pressé et maintenu enfoncé, elle sera mise fausse quand le bouton sera relâché.

Les boutons peuvent suivre le format suivant:

<button>
<button>

<checkbutton>

<radiobutton>

L’affichage d’un nombre peux suivre le format suivant:

<number> +
    <halpin>"number"</halpin> +
    <font>("Helvetica",24)</font> +
    <format>"+4.4f"</format> +
</number>

<number>

<font>('courier 10 pitch',100)</font>

<s32> +
<halpin>"simple-number"</halpin> +
<font>("Helvetica",24)</font> +
<format>"6d"</format> +
<width>6</width> +
</s32>

Seul l’affichage d’images au format gif est possible. Toutes les images doivent avoir la même taille. Les images doivent être toutes dans le même répertoire que le fichier ini (ou dans le répertoire courant pour un fonctionnement en ligne de commande avec halrun/halcmd).

<pyvcp> +
<image name='fwd' file='fwd.gif'/> +
<image name='rev' file='rev.gif'/> +
<vbox> +
<image_bit halpin='selectimage' images='fwd rev'/> +
</vbox> +
</pyvcp>

<pyvcp> +
<image name='stb' file='stb.gif'/> +
<image name='fwd' file='fwd.gif'/> +
<image name='rev' file='rev.gif'/> +
<vbox> +
<image_u32 halpin='selectimage' images='stb fwd rev'/> +
</vbox> +
</pyvcp>

Le widget barre de progression affiche la valeur d’un signal FLOAT, graphiquement dans une barre de progression et simultanément, en numérique.

<bar>

Le galvanomètre affiche la valeur d’un signal FLOAT dans un affichage à aiguille “à l’ancienne”.

<meter>

La roue codeuse contrôle une pin FLOAT. La valeur de la pin est augmentée ou diminuée de la valeur de resolution, à chaque pression sur une flèche, ou en positionnant la souris sur le nombre puis en tournant la molette de la souris.

<spinbox>

Le curseur contrôle une pin FLOAT. La valeur de la pin est augmentée ou diminuée en déplaçant le curseur, ou en positionnant la souris sur le curseur puis en tournant la molette de la souris.

<scale>

Noter que par défaut c’est min qui est affiché même si il est supérieur à max, à moins que min ne soit négatif.

Le bouton tournant imite le fonctionnement d’un vrai bouton tournant, en sortant sur un FLOAT HAL la valeur sur laquelle est positionné le curseur, que ce soit en le faisant tourner avec un mouvement circulaire, ou en tournant la molette de la souris. Un double click gauche augmente la résolution et un double click droit la diminue d’un digit. La sortie est limitée par les valeurs min et max. La variable cpr fixe le nombre de graduations sur le pourtour du cadran (prudence avec les grands nombres).

<dial> +
<size>200</size> +
<cpr>100</cpr> +
<min_>-15</min_> +
<max_>15</max_> +
<text>"Dial"</text> +
<init>0</init> +
<resolution>0.001</resolution> +
<halpin>"anaout"</halpin> +
<dialcolor>"yellow"</dialcolor> +
<edgecolor>"green"</edgecolor> +
<dotcolor>"black"</dotcolor> +
</dial>

Le bouton tournant imite le fonctionnement d’un vrai bouton tournant, en sortant sur une pin FLOAT la valeur sur laquelle est positionné le curseur, que ce soit en le faisant tourner avec un mouvement circulaire, ou en tournant la molette de la souris.

<jogwheel>

Le container bordure est spécifié avec deux tags utilisés ensembles. Le tag <relief> spécifie le type de bordure et le tag <bd> spécifie la largeur de la bordure.

Utilisez une Hbox lorsque vous voulez aligner les widgets, horizontalement, les uns à côtés des autres.

<hbox>

à l’intérieur d’une Hbox, vous pouvez utiliser les balises <boxfill fill=""/>, <boxanchor anchor=""/> et <boxexpand expand=""/> pour choisir le comportement des éléments contenus dans la boîte, lors d’un redimensionnement de la fenêtre. Pour des détails sur le comportement de fill, anchor, et expand, référez vous au manuel du pack Tk, pack(3tk). Par défaut, fill='y', anchor='center', expand='yes'.

Utilisez une Vbox lorsque vous voulez aligner les widgets verticalement, les uns au dessus des autres.

<vbox>

à l’intérieur d’une Hbox, vous pouvez utiliser les balises <boxfill fill=""/>, <boxanchor anchor=""/> et <boxexpand expand=""/> pour choisir le comportement des éléments contenus dans la boîte, lors d’un redimensionnement de la fenêtre. Pour des détails sur le comportement de fill, anchor, et expand, référez vous au manuel du pack Tk, pack(3tk). Par défaut, fill='y', anchor='center', expand='yes'.

Un label est un texte qui s’affiche sur le panneau.

<label>

Un labelframe est un cadre entouré d’un sillon et un label en haut à gauche.

<labelframe text="Label: Leds groupées">

Une table est un container qui permet d'écrire dans une grille de lignes et de colonnes. Chaque ligne débute avec la balise <tablerow/> . Un widget container peut être en lignes ou en colonnes par l’utilisation de la balise <tablespan rows= cols=/> . Les bordures des cellules contenant les widgets “sticky” peuvent être réglées grâce à l’utilisation de la balise <tablesticky sticky=/>. Une table peut s'étirer sur ses lignes et colonnes flexibles (sticky).

Exemple:

<table flexible_rows="[2]" flexible_columns="[1,4]">

image:images/pyvcp_table.png[]

Une interface à onglets peut économiser énormément d’espace.

<tabs> +
<names> ["spindle","green eggs"]</names> +
</tabs> +
<tabs> +
<names>["Spindle", "Green Eggs", "Ham"]</names> +
<vbox> +
<label> +
<text>"Spindle speed:"</text> +
</label> +
<bar> +
<halpin>"spindle-speed"</halpin> +
<max_>5000</max_> +
</bar> +
</vbox> +
<vbox> +
<label> +
<text>"(this is the green eggs tab)"</text> +
</label> +
</vbox> +
<vbox> +
<label> +
<text>"(this tab has nothing on it)"</text> +
</label> +
</vbox> +
</tabs>

Une jointure, pour une machine CNC est un des degrés physiques de liberté de la machine. Elle peut être linéaire (vis à billes) ou rotative (table tournante, jointures d’un bras robotisé). Il peut y avoir n’importe quel nombre de jointures sur une machine. Par exemple, un robot classique dispose de 6 jointures et une fraiseuse classique n’en a que 3.

Sur certaines machines, les jointures sont placées de manière à correspondre aux axes cinématiques (jointure 0 le long de l’axe X, jointure 1 le long de l’axe Y et jointure 2 le long de l’axe Z), ces machines sont appelées machines Cartésiennes (ou encore machines à cinématiques triviales . Ce sont les machines les plus courantes parmi les machines-outils mais elles ne sont pas courantes dans d’autres domaines comme les machines de soudage (ex: robots de soudage de type puma).

Pour effectuer la transformation de l’espace jointure en espace Cartésien nous allons utiliser quelques règles de trigonomètrie (le triangle rectangle déterminé par les points (0,0), (Dx,0), (Dx,Dy) et le triangle rectangle (Dx,0), (Bx,0) et (Dx,Dy).

Nous pouvons voir aisément que , de même que .

Si nous soustrayons l’un de l’autre nous aurons:

et par conséquent:

De là nous calculons:

Noter que le calcul inclus la racine carrée de la différence, mais qu’il n’en résulte pas un nombre réel. Si il n’y a aucune coordonnées Cartésienne pour la position de cette jointure, alors la position est dite singulière. Dans ce cas, la cinématique inverse retourne -1.

Traduction en code:

double AD2 = joints[0] * joints[0];
return 0;

La cinématique inverse est beaucoup plus simple dans notre exemple, de sorte que nous pouvons l'écrire directement:

ou traduite en code:

double x2 = pos->tran.x * pos->tran.x;

La latence correspond au temps pris par le PC pour stopper ce qui est en cours et répondre à une requête externe. Dans notre cas, la requête est l’horloge qui sert au cadencement des impulsions de pas. Plus basse est la latence, plus rapide pourra être l’horloge, plus rapides et plus douces seront les impulsions de pas.

La latence est de loin plus importante que la vitesse du CPU. Un Pentium II répondant à chaque interruption et toutes les 10 microsecondes pourra donner de meilleurs résultats qu’un rapide P4 HT.

Le CPU n’est pas le seul facteur déterminant la latence. Les cartes mères, cartes graphiques, ports USB et nombre d’autres choses peuvent la dégrader. La meilleure façon de savoir ce que vous pouvez attendre d’un PC consiste à exécuter le test de latence RTAI.

NE PAS ESSAYER DE LANCER EMC2 PENDANT QUE LE TEST EST EN COURS

Sous Ubuntu Dapper, vous pouvez lancer le test en ouvrant une console et en faisant:

sudo mkdir /dev/rtf;
sudo mknod /dev/rtf/3 c 150 3;
sudo mknod /dev/rtf3 c 150 3;
cd /usr/realtime*/testsuite/kern/latency; ./run

et vous devriez voir quelques choses comme:

ubuntu:/usr/realtime-2.6.12-magma/testsuite/kern/latency$ ./run
*
*
* Type ^C to stop this application. (Tapez CTRL-C pour arrêter cette application)
*
*

## RTAI latency calibration tool ##
# period = 100000 (ns)
# avrgtime = 1 (s)
# do not use the FPU
# start the timer
# timer_mode is oneshot

RTAI Testsuite - KERNEL latency (all data in nanoseconds)
RTH| lat min| ovl min| lat avg| lat max| ovl max| overruns
RTD|   -1571|   -1571|    1622|    8446|    8446|      0
RTD|   -1558|   -1571|    1607|    7704|    8446|      0
RTD|   -1568|   -1571|    1640|    7359|    8446|      0
RTD|   -1568|   -1571|    1653|    7594|    8446|      0
RTD|   -1568|   -1571|    1640|   10636|   10636|      0
RTD|   -1568|   -1571|    1640|   10636|   10636|      0

Pendant la durée du test, vous devez "abuser" de l’ordinateur. Déplacez les fenêtres tout autour de l'écran. Surfez sur le web. Déplacez quelques longs fichiers sur le disque. Jouez de la musique. Lancez un programme OpenGL comme glxgears. L’idée étant de pousser le PC au bout de ses limites pendant que le test de latence observe pour trouver les cas les moins bons.

L’avant dernière colonne marquée «ovl max» est la plus importante. Notez sa valeur, vous en aurez besoin par la suite. Elle contient les mesures de latence les plus mauvaises durant tout le test. Dans l’exemple ci-dessus, la valeur est de 10636 nanosecondes, soit 10.6 microsecondes, ce qui est excellent. Toutefois, le test de l’exemple n’a duré que quelques secondes (une ligne s’affiche à chaque seconde). Vous devez lancer le test pendant plusieurs minutes, parfois le plus mauvais temps n’apparaît pas vraiment, ou il apparaît quand vous faites une action particulière. J’ai une carte mère Intel qui marche très bien la plupart du temps, mais chaque 64 secondes arrive une valeur très mauvaise de 300uS. Par chance, ce cas a trouvé une solution, voyez ici: Le Wiky de Linuxcnc.

Que signifient les résultats du tableau, à quels résultats s’attendre? Si la valeur de votre «ovl max» est inférieure à 15-20 microsecondes (15000-20000 nanosecondes), l’ordinateur donnera d’excellents résultats. Si la latence maximale est près de 30-50 microsecondes, vous aurez de bons résultats, mais la fréquence maximale des pas risque d'être décevante, spécialement si vous utilisez des micropas ou si vous avec une vis avec un pas fin. Si la latence est de 100uS ou plus (100,000 nanosecondes), alors le PC n’est pas utilisable pour générer des trains d’impulsions par logiciel. Des chiffres suppérieurs à 1 milliseconde (1,000,000 nanosecondes) signifie que ce PC ne convient pas du tout pour EMC2, que vous pensiez générer les pas par logiciel ou non.

Notez que si vous obtenez de mauvais résultats, c’est peut être améliorable. Par exemple, un PC qui avait une latence très mauvaise (plusieurs millisecondes) en utilisant la carte graphique intégrée a vu le problème résolu par une carte graphique Matrox à 5$. EMC ne nécessite pas du matériel de pointe.

Les différente marques de cartes de pilotage de moteurs pas à pas demandent toutes des timing différents pour les impulsions de commande de pas et de direction. Aussi vous avez besoin d’accéder (ou Google) à la fiche des spécifications techniques de votre carte.

200 nS (0.2uS) before step pulse rising edge

+

+ 200 nS (0.2uS) hold after step pulse rising edge

Un carte Xylotex donne dans ses données techniques un superbe graphe du timing nécessaire, il indique:

Notez les valeurs que vous trouvez, vous en aurez besoin pour la prochaine étape.

BASE_PERIOD est l’horloge de votre EMC2. A chaque période, le générateur d’impulsions de pas décide si il est temps pour une autre impulsion. Une période plus courte vous permettra de générer plus d’impulsions par seconde, dans les limites. Mais si vous la réglez trop bas, votre ordinateur va passer autant de temps à générer des impulsions de pas que pour exécuter tous le reste de ses tâches, il finira peut-être même par se bloquer. La latence et la génération de pas exigent d’affecter la plus courte période utilisable, comme nous le verrons un peu plus loin.

Regardons l’exemple du Gecko en premier. Le G202 peut gérer des impulsions restant à l'état bas pendant 0.5uS et à l'état haut pendant 4.5uS, il a besoin que la broche de direction soit stable 1uS avant le front descendant et qu’elle reste stable pendant 20uS après le front descendant. La plus longue durée est de 20uS, c’est le temps de maintien. Une approche simple consisterait à fixer la période à 20uS. Ce qui signifierait que tous les changements d'état des lignes STEP et DIR serait espacés de 20uS. C’est tout bon, non?

Faux! Si la latence était de zéro, et que tous les fronts soient espacés de 20uS, tout irait bien. Mais tous les ordinateurs ont une latence. Si l’ordinateur a 11uS de latence, celà signifie que, ce que l’ordinateur exécute aura parfois un retard de 11uS et la fois suivante pourra être juste à l’heure, le délai entre le premier et le second sera seulement de 9uS. Si le premier génére l’impulsion de pas et le second change la broche de direction, le timing de 20uS requis par le G202 sera tout simplement violé. Cela signifie que votre moteur aura peut être fait un pas dans la mauvaise direction et que votre pièce ne sera pas à la cote.

Le côté vraiment mauvais de ce problème est qu’il peut être très très rare. Les pires latences sont celles qui ne se produisent que quelques fois par minute. Les chances qu’une mauvaise latence de ce genre arrive juste quand le moteur est en train de changer de direction sont faibles. Ainsi, vous avez de très rares erreurs qui vous ruinent une pièce de temps en temps et qui sont impossibles à résoudre.

La façon la plus simple pour éviter ce problème est de choisir une BASE_PERIOD qui soit la somme de la plus longue période requise par votre carte plus la durée de la pire latence de votre ordinateur. Si vous utilisez un Gecko avec un temps de maintien exigé de 20uS et que votre test de latence vous avait donné une latence maximum de 11uS, alors si vous définissez BASE_PERIOD à 20+11 = 31uS (31000 nanosecondes dans le fichier ini), vous aurez la garantie de répondre aux exigences de votre carte de pilotage.

Mais c’est un compromis. Faire une impulsion de pas demande au moins deux périodes. Une pour débuter l’impulsion, et une pour y mettre fin. Etant donné que la période est de 31uS, il faut 2x31 = 62uS pour créer une impulsion de pas. Ce qui signifie que la fréquence de pas maximum sera seulement de 16129 pas par seconde. Pas très bon. (Mais n’abandonnez pas, nous avons encore quelques réglages à faire dans la section suivante.)

Pour la Xylotex, la configuration demande des temps de maintien très courts de 200nS chacun (0.2uS). Le temps le plus long est de 2uS. Si vous avez 11uS de latence, alors vous pouvez définir BASE_PERIOD aussi bas que 11+2 = 13uS. Se débarrasser du long temps de maintien de 20uS aide vraiment. Avec une période de 13uS, un pas complet ne dure que 26uS = 2x13 et la fréquence maximum est de 38461 pas par seconde!

Mais ne commencez pas à célébrer celà. Notez que 13uS est une période très courte. Si vous essayez d’exécuter le générateur de pas toutes les 13uS, il ne restera peut-être pas assez de temps pour faire autre chose et votre ordinateur se bloquera. Si vous visez des périodes de moins de 25uS, vous devez commencer à 25uS ou plus, lancer EMC et voir comment les choses réagissent. Si tout va bien, vous pouvez réduire progressivement la période. Si le pointeur de la souris commence à être sacadé et que le reste du PC ralentit, votre période est un peu trop court. Retournez alors à la valeur précédente qui permettent le meilleur fonctionnement.

Dans ce cas, supposons que vous ayez commencé à 25uS, en essayant descendre à 13uS, vous trouvez que c’est autour de 16uS que se situe la limite la plus basse et qu’en dessous l’ordinateur ne répond plus très bien. Alors, vous utilisez 16uS. Avec une période à 16uS et une latence à 11uS, le temps de sortie le plus court sera de 16-11 = 5uS. La carte demande seulement 2uS, ainsi vous aurez une certaine marge. Il est bon d’avoir une marge si vous ne voulez pas perdre de pas parce que vous auriez réglé un timing trop court.

Quel est la fréquence de pas maximum? Rappelez-vous, deux périodes pour faire un pas. Vous avez réglé la période à 16uS alors qu’un pas prend 32uS. Il fonctionnera à 31250 pas par seconde, ce qui n’est pas mal.

Dans la section précédente, nous avons utilisé la carte de puissance Xylotex pour piloter nos moteurs avec une période de 16uS ce qui nous a donné une fréquence de pas de 31250 pas par seconde maximum. Alors que la Gecko a été bloquée à 31uS avec une assez mauvaise fréquence de pas de 16129 pas par seconde. L’exemple de la Xylotex est au mieux de ce que nous puissions faire. Mais la Gecko peut être ameliorées.

Le problème avec le G202 est le temps de maintien demandé de 20uS. Ca plus la latence de 11uS nous oblige à utiliser une période longue de 31uS. Mais le générateur de pas logiciel d’EMC2 a un certain nombre de paramètres qui permettent d’augmenter les différentes durées d’une période à plusieurs autres. Par exemple, si «steplen» passe de 1 à 2, alors il y aura deux périodes entre le début et la fin de l’impulsion. De même, si «dirhold» passe de 1 à 3, il y aura au moins trois périodes entre l’impulsion de pas et un changement d'état de la broche de direction.

Si nous pouvons utiliser «dirhold» pour le temps de maintien de 20uS demandé, alors le temps le plus long suivant sera de 4.5uS. Ajoutez les 11uS de latence à ces 4.5uS, et vous obtenez une période minimale de 15.5uS. Lorsque vous essayez 15.5uS, vous trouvez que l’ordinateur est très lent, donc vous régler sur 16uS. Si nous laissons «dirhold» à 1 (par défaut), alors le temps minimum entre le pas et la direction est de 16uS moins la période de latence de 11uS = 5uS, ce qui n’est pas suffisant. Nous avons besoin de 15 autres uS, puisque la période est de 16uS, nous avons besoin d’une période de plus. Nous allons donc passer «dirhold» de 1 à 2. Maintenant, le temps minimum entre la fin de l’impulsion et l’impulsion de changement de direction est de 5+16 = 21uS et nous n’avons pas à craindre que la Gecko parte dans la mauvaise direction en raison de la latence.

Si l’ordinateur a une latence de 11uS, alors la combinaison d’une période de base de 16uS et d’une valeur de «dirhold» de 2 garanti que nous serons toujours dans le respect des délais exigés par la Gecko. Pour les pas normaux (sans changement de direction), l’augmentation de la valeur de «dirhold» n’aura aucun effet. Il faudra deux périodes d’un total de 32uS pour faire un seul pas et nous avons la même fréquence de 31250 pas par seconde que nous avions eu avec la Xylotex.

Le temps de latence de 11uS utilisé dans cet exemple est très bon. Si vous travaillez par le biais de ces exemples avec des latences plus grandes, comme 20 ou 25uS, la fréquence de pas la plus grande à la fois pour la Xylotex et la Gecko sera plus faible. Mais les mêmes formules sont applicables pour calculer un BASE_PERIOD optimal et pour régler «dirhold» ou d’autres paramètres du générateur de pas.

Pour un système à moteurs pas à pas avec générateur de pas logiciel rapide et fiable, vous ne pouvez pas deviner la période et les autres paramètres de configuration. Vous devez faire des mesures sur votre ordinateur et faire les calculs qui garantirons les meilleurs signaux dont les moteurs ont besoin.

Pour rendre le calcul plus facile, j’ai créé une feuille de calcul Open Office (StepTimingCalculator). Vous entrez les résultats du test de latence et les timing de votre carte de pilotage et la feuille calcule la meilleure BASE_PERIOD. Ensuite, vous testez la période pour vous assurer que votre PC ne sera pas ralenti ou bloqué. Enfin, vous entrez dans la période actuelle et la feuille de calcul vous indiquera le réglage de stepgen nécessaire pour répondre aux exigences de votre carte de pilotage. Elle calcule aussi la fréquence de pas maximum que vous serez en mesure de générer.

J’ai ajouté quelques petites choses à la feuille de calcul pour calculer la fréquence maximum et quelques autres calculs.

Intuitivement, une boucle PID essaye d’automatiser ce que fait un opérateur muni d’un multimètre et d’un potentiomètre de contrôle. L’opérateur lit la mesure de sortie du procédé affichée sur le multimètre et utilise le bouton du potentiomètre pour ajuster l’entrée du procédé (l'«action») jusqu'à stabiliser la mesure de la sortie souhaîtée, affichée sur le multimètre.

Un boucle de régulation est composée de trois parties:

Quand le régulateur lit le capteur, il soustrait la valeur lue à la valeur de la consigne et ainsi, obtient l'«erreur de mesure». Il peut alors utiliser cette erreur pour calculer une correction à appliquer sur la variable d’entrée du procédé (l'«action») de sorte que cette correction tende à supprimer l’erreur mesurée en sortie de procédé.

Dans une boucle PID, la correction à partir de l’erreur est calculée de trois façons: P) l’erreur de mesure courante est soustraite directement (effet proportionnel), I) l’erreur est intégrée pendant un laps de temps (effet intégral), D) l’erreur est dérivée pendant un laps de temps (effet dérivé).

Une régulation à PID peut être utilisée dans n’importe quel procédé pour contrôler une variable mesurable, en manipulant d’autres variables de ce procédé. Par exemple, elle peut être utilisée pour contrôler: température, pression, débit, compostion chimique, vitesse et autres variables.

Dans certains systèmes de régulation, les régulateurs sont placés en série ou en parallèle. Dans ces cas, le régulateur «maître» produit les signaux utilisés par les régulateurs «esclaves». Une situation courante dans le contrôle des moteurs, la régulation de vitesse, qui peut demander que la vitesse du moteur soit contrôlée par un régulateur «esclave» (souvent intégré dans le variateur de fréquence du moteur) recevant en entrée une valeur proportionnelle à la vitesse. Cette entrée de l'«esclave» est alors fournie par la sortie du régulateur «maître», lequel reçoit la variable de consigne.

Le "PID" représente les abréviations des trois actions qu’il utilise pour effectuer ses corrections, ce sont des ajouts d’un signal à un autre. Tous agissent sur la quantité régulée. Les actions aboutissent finalement à des «soustractions» de l’erreur de mesure, parce que le signal proportionnel est habituellement négatif.

Pour cette action, l’erreur est multipliée par la constante P (pour Proportionnel) qui est négative, puis ajoutée (soustraction de l’erreur de mesure) à la quantitée régulée. P est valide uniquement sur la bande dans laquelle le signal de sortie du régulateur est proportionnel à l’erreur du système. Noter que si l’erreur de mesure est égale à zéro, la partie proportionnelle de la sortie du régulateur est également à zéro.

L’action intégrale fait intervenir la notion de temps. Elle tire profit du signal d’erreur passé qui est intégré (additionné) pendant un laps de temps, puis multiplié par la constante I (négative) ce qui en fait une moyenne, elle est enfin additionnée (soustraction de l’erreur de mesure) à la quantité régulée. La moyenne de l’erreur de mesure permet de trouver l’erreur moyenne entre la sortie du régulateur et la valeur de la consigne. Un système seulement proportionnel oscille en plus et en moins autour de la consigne du fait qu’en arrivant vers la consigne, l’erreur est à zéro, il n’enléve alors plus rien est dépasse la consigne, ou oscille et/ou se stabilise à une valeur trop basse ou trop élevée. L’addition sur l’entrée d’une proportion négative (soustraction) de l’erreur de mesure moyennée, permet toujours de réduire l'écart moyen entre la mesure en sortie et la consigne. Donc finalement, une boucle PI bien réglée verra sa sortie redescendre lentement à la valeur de la consigne.

L’action dérivée utilise aussi la notion de temps. Elle cherche à anticiper l’erreur future. La dérivée première (la pente de l’erreur) est calculée pour un laps de temps et multipliée par la constante (négative) D, puis elle est additionnée (soustraction de l’erreur de mesure) à la quantité régulée. L’action dérivée de la régulation fourni une réponse aux perturbations agissant sur le système. Plus important est le terme dérivé, plus rapide sera la réponse en sortie à une perturbation sur l’entrée.

Plus techniquement, une boucle PID peut être caractérisée comme un filtre appliqué sur un système complexe d’un domaine fréquentiel. C’est utilisé pour calculer si le système atteindra une valeur stable. Si les valeurs sont choisies incorrectement, le procédé entrera en oscillation et sa sortie n’atteindra jamais la consigne.

Régler une boucle de régulation consiste à agir sur les paramètres des différentes actions (gain du proportionnel, gain de l’intégral, gain de la dérivée) sur des valeurs optimales pour obtenir la réponse désirée sur la sortie du procédé. Le comportement des procédés varient selon les applications lors d’un changement de consigne. Certains procédés ne permettent aucun dépassement de la consigne. D’autres doivent minimiser l'énergie nécessaire pour atteindre un nouveau point de consigne. Généralement la stabilité de la réponse est requise, le procédé ne doit pas osciller quels que soient les conditions du procédé et le point de consigne.

Régler une boucle est rendu plus compliqué si le temps de réponse du procédé est long; il peut prendre plusieurs minutes, voir plusieurs heures pour qu’une modification de consigne produise un effet stable. Certains procédés ne sont pas linéaires et les paramètres qui fonctionnent bien à pleine charge ne marchent plus lors du démarrage hors charge du procédé. Cette section décrit quelques méthodes manuelles traditionnelles pour régler ces boucles.

Il existe plusieurs méthodes pour régler une boucle PID. Le choix de la méthode dépendra en grande partie de la possibilité ou non de mettre la boucle «hors production» pour la mise au point ainsi que de la vitesse de réponse du système. Si le système peut être mis hors production, la meilleure méthode de réglage consiste souvent à soumettre le système à un changement de consigne, à mesurer la réponse en fonction du temps et à l’aide de cette réponse à déterminer les paramètres de la régulation.

Si le système doit rester en production, une méthode de réglage consiste à mettre les valeurs I et D à  zéro. Augmenter ensuite le gain P jusqu'à ce que la sortie de la boucle oscille. Puis, augmenter le gain I jusqu'à ce que cesse l’oscillation. Enfin, augmenter le gain D jusqu'à  ce que la boucle soit suffisamment rapide pour atteindre rapidement sa consigne. Le réglage d’une boucle PID rapide provoque habituellement un léger dépassement de consigne pour avoir une montée plus rapide, mais certains systèmes ne le permettent pas.

Effets de l’augmentation des paramètres

Une autre méthode de réglage est la méthode dite de "Ziegler-Nichols", introduite par John G. Ziegler et Nathaniel B. Nichols. Elle commence comme la méthode précédente: réglage des gains I et D à zéro et acroîssement du gain P jusqu'à ce que la sortie du procédé commence à osciller. Noter alors le gain critique () et la période d’oscillation de la sortie (). Ajuster alors les termes P, I et D de la boucle comme sur la table ci-dessous:

La raison la plus fréquente dans une nouvelle installation pour que le moteur ne bouge pas est l’interversion entre le signal de pas et le signal de direction. Si, quand vous pressez le bouton de jog dans un sens puis dans l’autre, le moteur n’avance que d’un pas à chaque fois et toujours dans la même direction, vous êtes dans ce cas.

Certaine interfaces de pilotage de moteurs ont une broche d’activation (enable) ou demandent un signal de pompe de charge pour activer leurs sorties.

Si vous commandez une distance de déplacement précise sur un axe et que le déplacement réel ne correspond pas, alors l'échelle de l’axe n’est pas bonne.

Le concept d’erreur de suivi est étrange quand il s’agit de moteurs pas à pas. Etant un système en boucle ouverte, aucune contre réaction ne permet de savoir si le suivi est correct ou non. EMC calcule si il peut maintenir le suivi demandé par une commande, si ce n’est pas possible il stoppe le mouvement et affiche une erreur de suivi. Les erreurs de suivi sur les systèmes pas à pas sont habituellement les suivantes:

Toutes ces erreurs se produisent lorsque l’horloge temps réel n’est pas capable de fournir le nombre de pas nécessaire pour maintenir la vitesse requise par le réglage de la variable BASE_PERIOD. Ce qui peut se produire, par exemple après un test de latence trop bref pour obtenir un valeur fiable, dans ce cas, revenir à une valeur plus proche de ce qu’elle était et réessayez. C’est également le cas quand les valeurs de vitesse maximum et d’accélération maximum sont trop élevées.

Si un backlash a été ajouté, il est nécessaire d’augmenter STEPGEN_MAXACCEL aux environs du double de MAX_ACCELERATION dans la section [AXIS] du fichier INI et ce, pour chacun des axes sur lesquels un backlash a été ajouté. EMC2 utilise une "extra accélération" au moment de l’inversion de sens pour reprendre le jeu. Sans correction du backlash, l’accélération pour le générateur de pas peut être juste un peu plus basse que celle du planificateur de mouvements.

Quand vous rencontrez cette erreur:

RTAPI: ERROR: Unexpected realtime delay on task n

C’est généralement que la variable BASE_PERIOD dans la section [EMCMOT] du fichier ini a une valeur trop petite. Vous devez lancer un «Latency Test» pendant une durée plus longue pour voir si vous n’avez pas un délai excessif quelque part, responsable de ce problème. Si c’est le cas réajuster alors BASE_PERIOD avec la nouvelle valeur obtenue.

EMC2 vérifie le nombre de cycles du CPU entre les invocations du thread temps réel. Si certains éléments de votre matériel provoquent un délai excessif ou que les threads sont ajustés à des valeurs trop rapides, vous rencontrerez cette erreur.

lien vers latency-test

Si un de vos axes vibre, grogne ou fait des petits mouvements dans toutes les directions, c’est révélateur d’un mauvais timing d’impulsions de pas de ce moteur. Les paramètres du pilote matériel sont a vérifier et a ajuster. Il peut aussi y avoir des pertes de pas aux changements de direction. Si le moteur cale complétement, il est aussi possible que les paramètres MAX_ACCELERATION ou MAX_VELOCITY aient des valeurs trop élevées.

Le programme suivant vérifie que la configuration de l’axe Z est correcte. Copiez le programme dans le répertoire de votre emc2/nc_files nommez le «TestZ.ngc» ou similaire. Initialisez votre machine avec Z = 0.000 sur le dessus de la table. Chargez et lancez le programme. Il va effectuer 200 mouvements d’aller et retour entre 10.00 et 30.00mm. Si vous avez un problème de configuration, la position de l’axe Z affichée à la fin du programme, soit 10.00mm, ne correspondra pas à la position mesurée. Pour tester un autre axe remplacez simplement le Z des G0 par le nouvel axe.

( Faite Z=0 au dessus de la table avant de démarrer! )
( Ce programme teste les pertes de position en Z )
( msg, test 1 de la configuration de l'axe Z )
G21 #1000=100 ( boucle 100 fois )
( cette boucle comporte un delai après chaque mouvement )
( test des réglages d'accélération et de vitesse )
o100 while [#1000]
   G0 Z30.000
   G4 P0.250
   G0 Z10.000
   G4 P0.250
   #1000 = [#1000 - 1]
o100 endwhile
( msg, test 2 de la configuration de l'axe Z, pressez S pour continuer)
M1 (un arrêt ici)
#1000=100 ( boucle 100 fois )
( Les boucles suivantes n'ont plus de délai en fin de mouvements )
( test des
o101 while [#1000]
   G0 Z30.000 .
   G0 Z10.000
   #1000 = [#1000 - 1]
o101 endwhile
( msg, Fin Z doit être à 10mm au dessus de la table )
M2

Ouvrir un terminal depuis Applications > Accessoires > Terminal.

Dans ce terminal, tapez:

sudo gedit

Ouvrez un fichier depuis Fichiers, Ouvrir puis éditez le.

Pour afficher le chemin du répertoire courant dans le terminal tapez:

pwd

Pour remonter dans le répertoire précédent, tapez dans le terminal:

` cd ..`

Pour remonter de deux niveaux de répertoire, tapez dans le terminal:

` cd ../..`

Pour aller directement dans le sous-répertoire emc2/configs tapez:

cd emc2/configs

Pour voir le contenu du répertoire courant tapez:

dir

ou

ls

La commande «find» peut être un peu déroutante pour le nouvel utilisateur de Linux. La syntaxe de base est:

find répertoire_de_départ paramètres actions

Par exemple, pour trouver tous les fichiers .ini dans votre répertoire emc2 utilisez d’abord la commande «pwd» pour trouver le répertoire courant. Ouvrez un nouveau terminal et tapez:

pwd

il vous est retourné par exemple le résultat suivant:

/home/robert

Avec cette information vous pouvez taper, par exemple, la commande:

find /home/robert/emc2 -name *.ini -print

Le -name est le nom de fichier que vous recherchez et le -print indique à find d’afficher le résultat dans le terminal. Le *.ini indique à find de retourner tous les fichiers contenant l’extension .ini

Tapez dans un terminal:

grep -i -r 'texte à rechercher' *

Pour trouver tous les fichiers contenant le texte 'texte à rechercher' dans le répertoire courant et tous ses sous-répertoires et en ignorant la casse. Le paramètre -i demande d’ignorer la casse et le -r demande une recherche récursive (qui inclus tous les sous-répertoires dans la recherche). Le caractère * est un jocker indiquant «tous les fichiers».

Pour visualiser les messages du boot utilisez la commande «dmesg» depuis un terminal. Pour enregistrer ces messages dans un fichier redirigez les avec:

`dmesg > dmesg.txt`

Le contenu de ce fichier pourra alors être copié et collé à destination des personnes en ligne qui vous aideront à diagnostiquer votre problème.

Pour voir la liste du matériel utilisé par votre carte mère, tapez la commande suivante dans un terminal:

Lors de l’installation d’Ubuntu les réglages du moniteur sont détectés. Il peut arriver que ça fonctionne mal et que la résolution ne soit que celle d’un moniteur générique en 800x600.

Pour résoudre ce cas, suivez les instructions données ici:

https://help.ubuntu.com/community/FixVideoResolutionHowto