Auteurs : J. Filippini GENERATEUR DE PROFIL RÉSEAU NATIONAL DE RESSOURCES EN ÉLECTROTECHNIQUE

Transcription

1 Auteurs : J. Filippini GENERATEUR DE PROFIL 0

2 GENERATEUR DE PROFIL. 1- Les types de suivis. (sortes d'asservissements) Page 2 2- Le travail en temps différé. Page 2 3- La génération des signaux. 4- la sortie des signaux de l'élément informatique. Page 3 Programme pour sortir des signaux. Page 4 Le générateur de codes. Page 5 5- Les Types de trajectoires:(profil des mouvements) 5-1 le point à point. Page 6 Programme point à point. Page le paraxial. Page 8 Programme paraxial par échelons unitaires. Page 9 Programme paraxial par échelon de vitesse. Page L'interpolation linéaire. Page 12 Programme d'interpolation linéaire. Page L'interpolation circulaire. Page 15 Programme d'interpolation circulaire. Page le contournage. Page 18 Programme de contournage en temps différé. Page 'apprentissage d'un mouvement. Page 21 Programme d'apprentissage. Page 22 1

3 1 - Le type de suivi de mouvement. Les axes motorisés et esclaves du générateur de profil sont toujours asservis en suivi de consigne de position. Selon le rapport entre la valeur de la constante de temps globale de l'équipement et le temps de calcul du générateur, les mouvements sont qualifiés de lents ou de rapides. Le générateur de profil sera : Un générateur de profil de positions. Il fournira à l'axe motorisé la suite de codes séparés par des temps de durées variables. Cette manière de fonctionner ne peut s'appliquer qu'à des mouvements lents. Un générateur de profil de vitesse. Dans ce cas, le générateur fonctionne à fréquence constante et envoie des salves de signaux en nombre variable, séparés par des retards de durée fixe. Chaque salve de signaux est donc une consigne de vitesse. 2 - Le travail en temps différé. Lorsque les temps de calculs ne sont pas négligeables par rapport au retard représentant la vitesse du mouvement, il faut travailler en temps différé. La trajectoire est calculée puis stockée dans un fichier. Celui-ci est ensuite lu au moment de l'exécution du mouvement. 2

4 3 - La génération des signaux. Les ordres pénètrent dans l'axe asservi sous la forme de deux signaux binaires en quadrature. Voie a Voie b Transitions le nombre de transitions représente le nombre de pas élémentaires de la trajectoire du mouvement désirée, l'analyse de la succession des codes fournit le signe du sens du mouvement. Voie a Voie b Transitions Codes Signe La durée qui sépare les signaux ou les salves de signaux provoque la vitesse du mouvement. 4 - La sortie ou l'entrée des signaux de l'équipement informatique L'interfaçage entre le micro-ordinateur ou le micro-processeur et l'axe motorisé est obtenu à l'aide d'un coupleur pouvant prendre trois états. Dans cet exemple un PPI les signaux sont prélevés sur le bus des données. Pour chaque axe, il faut attribuer deux fils du bus des données au transit des codes du mouvement. 4-1 L'entrée ou la sortie des signaux des axes motorisés. L'entrée se fait SUR la carte M26 (support de mécanisme) par une connexion 3 fils (masse, voie a et voie b) sur le connecteur CON4, le connecteur CON3 débranché. il faut relier la masse sur la patte 1, les voies a et sur 3 et 5. La sortie d'informations à lieu sur le connecteur CON9 le fil de masse sur 3, les voies a et b sur 1 et L'observation des signaaux. Le signal émis par le générateur de profil est disponible en sortie du CNA de consigne PT5 sur la carte M24 (unité de traitement) L'observation de la trajectoire est disponible en sortie du CNA de mesure PT8. 3

5 Exemple de programme permettant de sortir 100 séries de 4 codes. Le coupleur est un Ilest installé à l'adresse $304. Ilfaut avant tout, déclarer les adresses des éléments périphériques et configurer le coupleur. Les signaux sortent sur le port [PA]. Les fils utilisés sur le bus des données sont Dl et DO. La liaisons avec l'axe motorisé comprend trois fils qui sont : Le fil de masse, les fils cod0 et codl connectés sur le connecteur CON4, voir document annexé. Les codes sont alors : D7 D6 D5 D4 D3 D2 Dl DO CODES $ $ $ $02 PROGRAM l00 codes; uses crt; CONST PA INTEGER=$304; PB INTEGER--$305; CR INTEGER=$307; PC INTEGER=$306; VAR f, j, : integer; Procedure pia; Begin PORT[CR]:=$82; (* Mode 0, A et C Sor en B en Ent *) End; beqin pia; for j := 0 to 100 do beqin port[pa] := $00; for f:=0 to 1000 do; port[pa] := $01; for f:=0 to 1000 do; port[pa] := $03; for f:=0 to 1000 do; port[pa] := $02; for f:=0 to 1000 do; end. 4

6 Le générateur de code. Il est configuré comme un compteur en anneau. Les codes sont rangés dans l'ordre de mouvement positif dans un tableau. Ils sont appelés par l'instruction Port [PC]. Il faut définir un indicateur de sens de mouvement s qui prend la valeur + ou - 1 et un pointeur de code "i". Si s = 1, sens positif, le pointeur de code i est incrémenté à chaque appel de la procédure lorsqu'il prend la valeur 5, on lui affecte la valeur 1. Si s= -1, sens négatif, le pointeur est alors régulièrement décrémenté. Lorsqu'il atteint la valeur 0, on lui affecte la valeur 4. Exemple : Compteur en anneau Générateur de code. var code : array[l..4] of integer; s, i : integer; Procedure codes; code [1] := $00; code [2] :=$01; code [3] :=$03; code [4] := $02; Procedure envoyer; i := i+s ; if i = 0 then i:=4; if i = 5 then i:= 1; Port [PC] := code[i]; 5

7 5 - Les Types de trajectoires. 5-1 Usinage en point à point. Le mode point à point est utilisé sur les machines permettant de réaliser les usinages suivants: Perçage, A1ésage, Lamage, Taraudage. Remarque : Le fonctionnement d'un plateau diviseur pourrait être obtenu en modifiant légèrement le programme. Il suffit pour cela de calculer le nombre de transitions correspondant à l'angle à parcourir. Lors des déplacements, l'outil n'est pas en prise, il en résulte que très souvent, le dépassement de position n'est pas nuisible et que les considérations relatives au mouvement sont généralement la cadence et les chocs. Le mobile se déplace d'un point à un autre d'un nombre constant de pas élémentaires généralement en dynamique libre, soit en calmant le mouvement par introduction d'un léger retard entre chaque incrément de pas. Ce retard est alors obtenu en affectant à une valeur différente de zéro. "d" est en retard en millisecondes. Lorsque l'axe des différentes cibles n'est pas parallèle à l'axe de la table d'usinage, il faut alors disposer de deux axes motorisés qui effectueront leur mouvement soit l'un après l'autre, soit simultanément. rogram pointapoint; uses crt; const (*adresses du PIA*) pa : integer = $304; pb : integer = $305; pc : integer = $306; rc : integer = $307; res: integer = $307; var code : array[1..4] of integer; s,o,e,eo,n, i,x,d: inteqer; Procedure pia; port[rc] := $82; (* mode 0, Pa sortie, pb entrée et pc sortie*) end ; Procedure cod ; code[l] $00; code[2] $01; code[3] $03; code[4] $02; Procedure envoyer ; i := i+s 6

8 if i = O then i: =4; if i = 5 then i: 1; Port [pc] := code[i]; BEGIN cod; pia; s := 1; x:=0 ; (*introduction de la trajectoire*) Writeln ('longueur de la tra5ectoire en pas?'); Readîn (e0); writeln( 'Combien d' 'échelons successifs?'); Readln(n); Writeln ('Si vous voulez ralentir le mouvement "d" en ms?); Readln(d); (*Calculs des paramètres*) if e0 <0 then s := -l ; eo := -eo; (*Début du travail*) while x < n do x := x+l; Writeln( 'envoyez la transition'); readln(o); e:= 0; while e<e0 do e := e + 1 ; envoyer; delay(d); END. 7

9 5 2 Usinage en paraxial. Ce mode d'usinage est celui d'une fraiseuse qui effectue des opérations d'usinage parallèles aux axes perpendiculaires x et y. L'outil étant en prise, le dépassement de position n'est plus toléré. Généralement, la vitesse désirée pour l'usinage est constante, on ne peut pourtant pas éviter les périodes transitoires de mise en mouvement et d'arrêt. Pour éviter les aléas on préfère contrôler les périodes transitoires. Générateur de profil par échelon unitaire de position. Ce mode de fonctionnement ne convient que pour les trajectoires lentes, trajectoires dont l'inverse de la vitesse maximale 1/v en seconde par pas est supérieur a la durée représentée par un incrément de temporisation. On impose la vitesse de croisière en incréments par unité de temps, la longueur du mouvement en incréments et l'accélération en incréments par unité de temps au carré. Le générateur, compte tenu de la trajectoire à effectuer calcule pour chaque sorte de mouvement le délai qui doit séparer deux codes successifs ou une série de nombre constant de codes successifs. Exemple : trajectoire à profil trapézoidal de vitesse. program profil; uses crt; const (*adresses du PIA*) pa : integer = $304; pb : integer = $305; pc : integer = $306; rc : integer = $307; res: integer = $307; var code : array[l..4] of integer; a, b, i, e, e0, ea, ed, ec, v, d,s: integer; t,tl,t0,dt: real; Procedure pia; port[rc] := $82; (* mode O, Pa sortie, pb entrée et pc sortie*) Procedure cod; code[l] $00; code[2] := $01; code[3] := $03; code[4] := $02; Procedure envoyer; 8

10 i:= i+s ; if i = 0 then i :=4; if i = 5 then i: 1; Port [pc] := code[i]; BEGIN cod; pia; s := 1; (*introduction de la trajectoire*) Writeln ('longueur de la trajectoire eo'); Readîn (eo); Writeln ('Vitesse de croisière en pas/seconde '); readîn (v); Writeln ('Accélération en pas/seconde au carré?'); Readln(a); (*Calculs des paramètres*) if e0 <0 then s := -l ; e0 := -e0; ea := (v*v) div(2*a); if ea >= e0/2 then ea := e0 div 2;ec := 0; ed := ea; end else ea := ea; ec := e0 - (2*ea); ed := ea; (*Période d' 'accélération*) e =0 ; Tl=0; While e<ea do e:= e+l; b:=(2*e div a); t:=sqrt(b); dt := int(t-t1); t1 := t; d:= trunc(loo0*dt); delay(d); envoyer; (*période à vitesse constante*) e:=0; while e<ec do e := e + 1 ;delay(d);envoyer; (*période de déceleration*) e:= ed; While e> 0 do e := e-l; b:=(2*e div a); t:=sqrt(b); dt := (tl-t); 9

11 tl := t; d := trunc(lo0o*dt); delay(d); envoyer; END.-> Générateur de profil par échelons successifs de vitesse. Le générateur, compte tenu de la trajectoire à effectuer calcule le nombre de pas a parcourir par période. Exemple: profil trapézoidal de vitesse. Programme générateur de profil par échelons de vitesse. program profilvitesse; uses crt; const (*adresses du PIA*) pa : integer = $304; pb : integer = $305; pc : integer = $306; rc : integer = $307; res: integer = $307; var code : array[l..4] 0f integer; a,b, i, e, eo, ea, ed, ec, v, d: integer; dc, y,ex: integer; dt,de,db, dd,x : real; t,tl,to: real; s, r: integer; Procédure pia; port[rc] := $82; (* mode 0, Pa sortie, pb entrée et pc sortie*) Procedure cod; code[l] := $00; code[2] := $01; code[3] := $03; code[4] := $02; procedure calcul~envoi; if ex < (e+dc) then de := ex - e; dc:= trunc(de); dd := de-dc; e := e+dc; db := int (de); x : =0; while x < db do i:= i+s if i = 0 then i:= 4; 10

12 if i = 5 then i: 1; Port [pc] := code[i]; x:= x+l; delay(100); BEGIN cod; pia; s := 1; i =0 ;y:=0 ;ex:=0; (*introduction de la trajectoire*) Writeln ('longueur de la trajectoire L'); Readîn (eo); Writeln ('Vitesse de croisière en pas/seconde '); readîn (v); Writeln ('Accélération en pas/seconde au carré?'); Readîn (a); (*Calculs des paramètres*) if e0 <0 then s := -l ; eo := -eo; if ea := v div(2*a)*v; ea >= e0/2 then ea := e0 div 2;ec := 0; ed := ea; end else ea := ea; ec := e0 - (2*ea); ed := ea; (*Période d' 'accélération*) e:=0;ex:=ea; T:=0;dd:=0;dc:=0;dt:=l; While e<ex do t := t + 1; de := ( a * t* dt)+dd ; calcul_envoi; (*période à vitesse constante*) ex:=(ec+ea); while e< ex do beqin de := v*dt; ` calcul_envoi; (*période de décélération*) t:=0;ex:=e0; While e< ex do de:=( v * dt a*t*dt); t:= t+l; calcul_envoi; end ; END. 11

13 Comparaison de la trajectoire idéale et de la trajectoire réel1e par échelon unitaire de position 5 3 Usinage en interpolation linéaire. L'usinage par interpolation linéaire consiste à usiner des segments de droites non parallèles aux axes x et y de la table. Il faut donc qérer les mouvements de deux axes motorisés. La vitesse Vx affichée est la résultante des deux mouvements Va et Vb. On donne par exemple la tangente "Tg" de la direction du mouvement résultant. Il faut en permanence que Vx 2 = Va 2 + Vb 2. En conséquence par unité de temps, les espaces parcourus seront: Ex 2 =Ea 2 + Eb 2 avec Eb/Ea = Tg = Vb/Va À tout moment, y compris pendant les périodes transitoires de mise en mouvement et d'arrêt, le rapport Vb/Va doit rester constant. Le générateur de profil doit par unité de temps "T", envoyer des salves de codes Nb et N3 dans le rapport "Tg". Il faut attribuer deux fils du bus des données à chaque Axe. Dans cet exemple, les fils D5 et D4 sont attribués à l'axe A et les fils Dl et DO à l'axe B. Il faut définir deux pointeurs de code (ia et ib), le code du mouvement sera la somme du code (ia) et du code(ib). Les deux axes effectuent des mouvements dont le profil de vitesse est trapézoïdal. program interpolationlin ; uses crt; const (*adresses du PIA*) pa : integer = $304; pb : integer = $305; pc : integer = $306; 12

14 rc : integer = $307; res: integer = $307; var codea : array[l..4] of integer; codeb : array[l..4] of integer; na, nb, i, d, ib, ia, sa, sb: integer; Ex,Ea,Eb,y,h:integer; z,a,b,x,vx,tg:real; Procedure pia; port[rc] := $82; (* mode 0, Pa sortie, pb entrée et pc sortie*) Procedure cod; codea[l] := $00; codea[2] := $01; codea[3] := $03; codea[4] := $02; codeb[1] := $00; codeb[2] := $10; codeb[3] := $30; codeb[4] := $20; Procedure envoyer; na :=0; if na < A then na ;= na+i ; ia := ia+sa if ia = 0 then ia:=4; if ia = 5 then ia:= 1; nb:=0; if nb < B then nb:=nb+l; ib:=ib+sb; if ib = 0 then ib := 4 ; if ib = 5 then ib := 1 ; Port [pc] ':= codea[ia] + codeb [ib]; (* writeln (port[pc]); *) delay(l00); BEGIN cod; pia; x:=0 ;sa:=1;sb:=l;na:=0;nb:=0; (*introduction de la trajectoire*) Writeln ('longueur de la trajectoire en pas?'); 13

15 Readîn (Ex); Writeln( 'vitesse du mouvement en pas par seconde?'); Readln(Vx); writeln('tangente de la trajectoire?'); Readln(Tg); Writeln('Introduisez le sens du mouvement sur X +/-l? ) ; Readln(Sa); Writeln('introduisez le sens du mouvement sur Y +/-l? ) ; readln(sb); (*Calculs des paramètres*) X:= Vx; a:= sqrt( sqr(x)/(l+sqr(tg))); b: a/tg; Z:= a; (*Début du travail*) If A < B then Z := B for y := 0 to round ( ex/vx) do for h := 0 to round(z) do envoyer; END.-> Interpolation linéaire. Répartition des impulsions sur les axes X et Y pour obtenir une droite de tangente 1/2 14

16 Erreur de suivi. Temps de réponse global Erreur de profil Mise en évidence de l'erreur de suivi provoqué par la réponse globale de l'axe motorisé. 15

17 Trajectoires réelles respectives des axes X et y ayant des constantes de temps différentes. La trajectoire XY désirée fait un angle de 45 degrés. Comparaison des trajectoires XY désirée et réelle Il est recommandé de donner aux deux axes des constantes de temps globales identiques. Dans ce cas, l'erreur de profil est nulle. 16

18 Interpolation circulaire. L'usinage en interpolation circulaire consiste à réaliser des cercles ou des portions de cercles. La précision du générateur de profil. En réalité, le contour piloté par le générateur de profil est un polygone régulier dont le nombre de cotés est tel que le polygone est inscrit entre deux cercles de tolérances de rayons "RM" et "rm". Il appartient au programmeur de déterminer le nombre "n" de cotés du polygone et l'angle de pas "a". La précision de l'usinage. rm = RN cos( 2*PI/n) a = 2*PI/n Elle est entachée de deux erreurs liées au mécanisme. L'erreur de profil : Elle est donnée par la relation suivante : ep = (V/2)*Sin(2a)*(Ty-Tx) V:Vitesse linéaire, a: angle de la trajectoire, Ty et Tx constantes de temps globales respectives des axes Y et X. On voit que si elles sont égale, l'erreur de profil est nulle. Avant la mise en service, il faudra réaliser une réponse à un échelon de position en boucle fermée sur les deux axes et faire en sorte que les réponses soient superposées. L'erreur de rayon. Elle dépend de l'erreur de traînage de chaque axe. Il est recommandé de donner aux deux axes des constantes de temps globale identiques. Dans ce cas, l'erreur de rayon est alors D(R)=T 2 *V 2 /2*R R : Rayon recherché pour la position, T : constante de temps commune aux deux axes, V : vitesse linéaire. Exemple de programme d'interpolation circulaire. program interpolationcircula ire; uses crt; const pa : integer = $304; pb : integer = $305; pc : integer = $306; rc : integer = $307; 17

19 res : integer = $307; var codea : array[l..4] of integer; codeb : array[l..4] of integer; na,nb,d: integer; y,h,ia,ib,sy,sx:inteqer; z,a,b,x,vx,tg:real; at,ao,vz,r,t,np,st,dx,dy,nx,ny,rx,ry,im:real; Procedure pia; port[rc] := $82; (* mode 0, Pa sortie, pb entrée et pc sortie*) Procedure cod; codea[l] := $00 ; (* à modifier*) codea[2] := $01; codea[3] := $03; codea[4] := $02; codeb[ 1] := $00; codeb[ 2] := $10; codeb[ 3] := $30; codeb[4] := $20; Procedure envoyer; if na < abs(nx) then na := na+l; ia := ia+sx if ia = 0 then ia:=4; if ia = 5 then ia:= 1; if nb <abs(ny) then nb:=nb+l; ib:=ib+sy; if ib 0 then ib := 4; if ib = 5 then ib := 1; Port [pc] := codea[ia] + codeb [ib]; (* writeln (port[pc]); *) delay(100); procedure calcul; dx := R*Im*Sin(a)*cos(ao+y*a); If dx < 0 then sx := -1; nx := round(dx+rx); rx := dx - nx; dy := R*Im*Sin(a)*Sin(ao+y*a); if dy < 0 then sy := -1; ny := round(dy+ry); ry :-- dy - ny; if abs(nx) > abs(ny) then z := abs(nx) else z := abs(ny); 18

20 BEGIN cod; pia; x:=0 ;sa:=l ;sb:=l ;na:=0 ;nb:=0; (*introduction de la trajectoire*) Writeln ('angle de la trajectoire en degrés?'); Readîn (at); Writeln ('angle d origine en degrés?'); Readin (ao); Writeln ('Rayon du cercle en mm?'); Readîn (R); Writeln ( 'vitesse du mouvement en pas par seconde?'); Readln(Vz); (*Calculs des paramètres*) a := 1;st:= 1; im:=1000; if at < 0 then st := -l t: 1 / vz ; Np := abs( at/a); (*Début du travail*) for y := 0 to round ( np) do na:=0;nb:=0; calcul; for h := 0 to round(z) do envoyer; END.-> Représentation des cercles de tolérance de rayon RM et rm en fonction de l'angle a/2 et du nombre de cotés du polygone régulier. 19

21 Usinage d'une portion de cercle. Répartition des impulsions sur les axes X et Y. Représentation de l'erreur de profil "ep" et de l'erreur de rayon "dr" 20

22 5-4 Usinage en contournage. L'usinage par contournage est utilisé sur des fraiseuses lorsque la forme à usiner est quelconque. Il faut alors décomposer le mouvement en une série de droites comprises dans une enveloppe de tolérances. Le réglage du correcteur permettra d'arrondir les angles. Il faut donc pour chaque forme élémentaire, définir une fonction calcul personnalisée. Pour gagner en rapidité d'exécution, le travail est réalisé en temps différé : - Premier temps, on calcule les différents échelons de vitesse qui sont stockés dans un fichier de points. - Dans un second temps, on sort à période constante les échelons successifs de vitesse. Le programme comprend deux parties. La première qui consiste à remplir un fichier de deux colonnes l'une comportant le code de la position à atteindre et l'autre le délai à respecter avant l'envoi du code suivant. Exemple de programme de contournage fonctionnant en temps différé. program contournage; uses crt; const (*adresses du PIA*) pa : integer = $304; pb : integer = $305; pc : integer = $306; rc : integer = $307; res: integer = $307; var codea : array[l..4] of integer; codeb : array[l..4] 0f integer; na, nb, i, d, ib, ia, sa, sb: integer; y, h, w: integer; A, B, X, nbc, nbl, z : real; k,j,nbli,nbci,s:integer; val : real; f: code; nfm:string[8]; type code=file of real; Procedure pia; port[rc] := $82; (* mode 0, Pa sortie, pb entrée et pc sortie*) Procedure cod; codea[l] := $00; codea[ 2] := $01; codea[ 3] := $03; codea[4] := $02; codeb[l] := $00; codeb[ 2] := $10; 21

23 codeb( 3] := $30; codeb[ 4] := $20; Procedure envoyer; na:=0; if na < A then na := na+1; ia := ia+sa if ia = 0 then ia:=4; if ia = 5 then la:= 1; nb:=0; if nb < B then nb:=nb+l; ib:=ib+sb; if ib = 0 then ib := 4; if ib = 5 then ib := 1; val := 1000/z; write(f,val); val := codea[ia] + codeb [ib]; write(f,val); writeln (val); delay(l00); procedure calcul; (* il appartient à 1''utilisateur de personnaliser cette fonction*) a:=5; sa:= 1; b := 4;sb:= 1; (* fonction mathématique à déf inir*) z:= a; if a < b then z:= b; 22

24 (*Corps du programme:*) BEGIN x:=0 ;sa:=1 ;sb:=1 ;na:=0;nb:=0; (* remplissage du fichier *) cod; pia; nfm := 'salut'; assign(f,nfm); rewrite(f); write( 'n0mbre de lignes du tableau:') ; readln(nbl); write(f,nbl); nbc:= 2; (* colonne 1 le retard, colonne 2 le code*) write(f,nbc); nbli:=round(nbl); nbci :=round(nbc); (* debut calcul*) for i:= 1 to nbli do calcul; envoyer; close(f) (* reinjection de la trajectoire*) Writeln( 'pour commencer le mouvement, appuyez sur un chiffre '); readln(w); Writeln( 'introduisez le coefficient de la vitesse ') ; readln(w); if w = 0 then w:= 1; reset(f); read(f,nbl,nbc); writeln(' ce tableau a: 'nbl :2 :0, lignes,nbc:2:0, 'c0l0nnes,'); seek(f,2); writeln; for i:= i to nbli do read(f,val); (* lecture indice de retard*) s:=r0und( val); for j := 0 to w*s do; (* boucle de retard*) read(f,val); (*lecture du code*) s: round(val); port[pc] := s; (*envoi du code*) end.-> close(f); 23

25 6 - L'Apprentissage d'un mouvement. L'apprentissage d'un mouvement consiste à exécuter un mouvement de manière autonome et à demander au qénérateur de profil de répéter ce mouvement. Les codeurs des moteurs du mouvement à recopier sont connectés au générateur de profil, ils sont, dans cet exemple, branchés sur le port [PB] qui peut recevoir jusqu'à 4 axes motorisés. Les consignes des axes à commander sont connectées sur le port [PC] dans le même ordre que celui des codeurs sur le port [PB]. Dans un premier temps, on enregistre le mouvement dans un fichier de deux colonnes, l'une contient le code global du mouvement l'autre, le délai qui sépare deux codes différents et successifs. Dans un second temps, on renvoie la liste des codes enregistrés séparés par les durées prévues. Pour ralentir le mouvement, il suffit de modifier le retard entre chaque sortie. Le générateur renvoie le programme appris de manière similaire, toutes les variations de vitesses sont enregistrées. On peut envisager de renvoyer le mouvement à vitesse linéaire constante. Pour cela, il faut 1 - Ouvrir un nouveau fichier qui contiendra des collections de codes nx et ny de manière que nx 2 + ny 2 = nz 2 (valeur constante dépendant de la vitesse désirée), ces codes proviennent du fichier rempli lors de i 'apprentissage. 2 - Sortir ces collections par salves séparées par des durées égales. program apprentissage~de~trajectoire; uses crt; const var type var adresses relative au PPI *) pa integer $304; pb integer = $305; pc integer = $306; rc integer = $307; res integer = $307; w : integer; code=file 0f real; i, j,nbli, nbci, s: integer; nbc, nbl, x, z, y, h: real; val : real; f :code; nfm:string[8]; Procedure pia; port[rc] := $82; (* mode 0, Pa sortie, pb entrée et pc sortie*) 24

26 pia; nfm := 'salut'; assign(f,nfm); rewrite(f); write( 'nombre de pas du mouvement:') ;readln(nbl); write(f,nbl); nbc:= 2; (* colonne 1 le retard, colonne 2 le code*) write(f,nbc); nbli:=round(nbl); nbci:=round(nbc); (* lecture de la trajectoire sur le port B *) z :=0 ; (* initialisation retard*) port[pb] := $00; (*initialisation du code*) Writeln(Pour commencer, envoyez un chiffre '); readln(w); for i:= 1 to nbli do val : z; write(f,val);(* nombre de boucles avant changement*) val: port[pb]; (* nouveau code *) write(f,val); y: port[pb]; (* pointage du dernier code lu*) repeat (* boucle tant que rien ne change*) z : =z+l; until port[pb] <> (*controle*) close(f) (* reinjection de la trajectoire*) Writeln('pour commencer le mouvement, appuyez sur un chiffre '); readln(w); Writeln('introduisez le coefficient de la vitesse '); readln(w); if w =0 then w:=1; reset(f); read(f,nbl,nbc); writeln( 'ce tableau a: ',nbl:2:0, 'lignes et', nbc: 2 : 0, 'colonnes,'); seek(f,2); writeln; for i: 1 to nbli do read(f,val); (* lecture indice de retard*) s:=round( val); for j := 0 to w*s do; (* boucle de retard*) read(f,val); (*lecture du code*) s:= round(val); port[pc] := s; (*envoi du code*) end. close(f); 25

27 CARTE M 24 Unité de traitement 26

28 CARTE M26 Support du mécanisme. 27