Go Down

Topic: [Processing3] visualiseur d'embiellage pour ailes battantes. (Read 1 time) previous topic - next topic

jfs

Bonjour à tous,

Depuis quelques jours j'essaye de faire un petit programme avec Processing pour "calculer" un embiellage pour un avion à ailes battantes.

Ceci devrait me permettre de trouver la solutions optimum pour que les ailes soient coordonnées au mieux au PMH et au PMB.

Le problème d'un tel montage est le changement permanent des angles entre la bielle, l'aile et le vilebrequin.... difficile de trouver les points de référence à utiliser et surtout comment les utiliser.

Après pas mal de réflexion sur la méthode à utiliser, je me suis lancé sur un principe un peu barbare en fixant la longueur de la bielle et après contrôle de cette longueur je fais un ajustage de la course sur la courbe que décrit le pivot de l'aile.

ça fonctionne avec certaines configurations du système mais dans certains cas ça part en cacahouètes... c'est Kammo qui va être content pour l'apéro  :D.

L'affichage est également très lent... si c'est possible d'améliorer je suis preneur  ;)

J'aurais besoin d'un coup de main sur cette réflexion, quitte à me faire recommencer depuis le début.

Par la suite j'aimerais faire des montages à optons avec le nombre de paire d'ailes possibles, le décalage des manetons, etc.

Merci pour votre attention.

Code: [Select]

float x =0;

float course= 25;
float a= 40; // distance bielle pivot d'aile
float Bielle=80;  // longueur de la bielle
float Angle = 40;  // angle de décalage entre deux mannetons
float AxeAile=10;  //distance du pivot de l'aile depuis l'axe
float Dist_Pivot_Vilo=75;

float H=0;
float c=0;

int i=1;
int D=0;
int G=90;
float old_DD=0;
float old_DG=0;
float old_BielleD=0;
float old_BielleG=0;
int sens = 1;

void setup() {
  size(600, 600); //,P2D);
  frameRate(25);
  background(255);
  strokeWeight(.2);
  stroke(0);
  noFill();
  smooth();
}

void draw() {
  scale(1.5);
  background(255);
  translate(200, 300);
  strokeWeight(.01);
  stroke(0);
  //axes
  ellipse(0, 0, course, course); // course maneton vilebrequin
  line(0, 70, 0, -150);  // axe vertical vilebrequin
  line(70, 0, -70, 0);  //  axe horizontal vilebrequin
  line(70, -Dist_Pivot_Vilo, -70, -Dist_Pivot_Vilo);  //  axe horizontal pivot d'ailes
  line(AxeAile, -Dist_Pivot_Vilo+15, AxeAile, -Dist_Pivot_Vilo-15);  // axe vertical pivot d'aile droite
  line(-AxeAile, -Dist_Pivot_Vilo+15, -AxeAile, -Dist_Pivot_Vilo-15);  // axe vertical pivot d'aile gauche

  strokeWeight(.5);
  stroke(255, 176, 18);
  // orange droite
  ellipse (course/2*sin(radians(-270+i)), course/2*cos(radians(-270+i)), 5, 5);

  PVector WingD = new PVector(AxeAile+a/2*sin(radians(sens*-270+D)), -Dist_Pivot_Vilo+ a/2*cos(radians(-270+D)));
  PVector WingG = new PVector(AxeAile+a/2*sin(radians(-sens*270+G)), -Dist_Pivot_Vilo+ a/2*cos(radians(270+G)));

  PVector MannetonD = new PVector(course/2*sin(radians(-270+i)), course/2*cos(radians(-270+i)));
  PVector MannetonG = new PVector(course/2*sin(radians(-270+i+Angle)), course/2*cos(radians(-270+i+Angle)));
  //(course/2*sin(radians(-270+i+Angle)), course/2*cos(radians(-270+i+Angle)), 5, 5);

  PVector WingAxelD = new PVector (30, -Dist_Pivot_Vilo);
  PVector WingAxelG = new PVector (30, -Dist_Pivot_Vilo);

  float DD = MannetonD.dist(WingAxelD);
  float DG = MannetonG.dist(WingAxelG);
  float BielleD = MannetonD.dist(WingD); // longueur de la bielle droite
  float BielleG = MannetonG.dist(WingG); // longueur de la bielle gauche
  //println ((radians(-270+i)));
  println(" ");
  print("D");
  println(int(BielleD));  //
  print("G");
  println(int(BielleG));
  println(" ");
  print("D");
  println(DD);
  print("G");
  println(DG);
  if (BielleD>Bielle) {
    D--;
  }
  if (BielleD<Bielle) {
    D++;
  }

  if (old_DD > DD) {
    WingD.sub(0, 0);
    WingD.mult(1);
    line(MannetonD.x, MannetonD.y, WingD.x, WingD.y);
    ellipse (AxeAile, -Dist_Pivot_Vilo, a, a);  
    ellipse (WingD.x, WingD.y, 5, 5);   // axe bielle d'aile
    D++;
  } else {
    WingD.sub(0, 0);
    WingD.mult(1);
    line(MannetonD.x, MannetonD.y, WingD.x, WingD.y);
    ellipse (AxeAile, -Dist_Pivot_Vilo, a, a);  
    ellipse (WingD.x, WingD.y, 5, 5);   // axe bielle d'aile
    D--;
  }


  strokeWeight(.5);
  stroke(2, 201, 23);
  // vert gauche
  ellipse (course/2*sin(radians(-270+i+Angle)), course/2*cos(radians(-270+i+Angle)), 5, 5); // 90 pour 90º entre le violet et le bleu

  if (BielleG>Bielle) {
    G++;
  }
  if (BielleG<Bielle) {
    G--;
  }

  if (old_DG > DG) {
    WingG.sub(0, 0);
    WingG.mult(1);
    line(MannetonG.x, MannetonG.y, -WingG.x, WingG.y);
    ellipse (-AxeAile, -Dist_Pivot_Vilo, a, a);  
    ellipse (-WingG.x, WingG.y, 5, 5);   // axe bielle d'aile
    G--;
  } else {
    WingG.sub(0, 0);
    WingG.mult(1);
    line(MannetonG.x, MannetonG.y, -WingG.x, WingG.y);
    ellipse (-AxeAile, -Dist_Pivot_Vilo, a, a);  
    ellipse (-WingG.x, WingG.y, 5, 5);   // axe bielle d'aile
    G++;
  }


  old_BielleD = BielleD;
  old_BielleG = BielleG;
  old_DD = DD;
  old_DG = DG;

  i++;
}
Pas d'aide par MP !!!

Concernant le fonctionnement du forum tout se trouve dans les messages épinglés en tête de page.

jfs

En continuant de gratter sur le net je suis enfin tombé sur un site qui explicite la relation entre deux leviers de longueur différentes connectés par une bielle ainsi que pas mal de formules.... :

https://www.lucidarme.me/transmission-par-bielles/
Pas d'aide par MP !!!

Concernant le fonctionnement du forum tout se trouve dans les messages épinglés en tête de page.

jfs

En partant du site indiqué dans le message précédent j'ai utilisé la distance entre P1 et M  afin de déterminer l'angle Ɵ2.

J'ai repris tout mon sketch, la bielle est moins "élastique", mais uniquement dans la configuration de base. Pour cela j'ai du compenser avec la valeur "1040" ( dont je n'ai pas la correspondance ).

Si je déplace le pivot de l'aile par rapport a l'axe du vilebrequin, cela ne fonctionne plus correctement non plus.

Code: [Select]

float l1=20;  // >> course
float l2 = 20; // distance bielle pivot d'aile >> Maneton_aile
float Bielle=0;  // longueur de la bielle
float Decalage_Maneton = 40;  // angle de décalage entre deux mannetons
float Dec_Piv_aile =0;  //distance du pivot de l'aile depuis l'axe >> AxeAile
float X=75;
float angle=0;
float Theta_2 = 0;
float Theta_2_test = 0;
float Theta_1 = 0;
float Theta_2_2 =0;
float P1_M = 0;
float L = 0;
float flag = 0;

float A = 0;
float C = 0;

float x = 0 ;
float y = 0 ;

float RPM = 360; // vitesse de rotation

int i = 0;

PVector  O, P1, M, P2, v5, H;

void setup() {
  size(600, 600); //,P2D);
  //frameRate(40);
  background(255);
  strokeWeight(.2);
  stroke(0);
  noFill();
  smooth();
  O = new PVector(0, 0); //centre du vilebrequin
  P1 = new PVector( l1, 0);  //maneton
  // M = new PVector( Dec_Piv_aile, -Dist_Pivot_Vilo); //pivot de l'aile
  M = new PVector( 0+Dec_Piv_aile, -X); //pivot de l'aile
  // P2 = new PVector( l2 + Dec_Piv_aile , -Dist_Pivot_Vilo);  // jonction bielle - aile
  P2 = new PVector( l2, -X);  // jonction bielle - aile
  v5 = new PVector(0, -50); //valeur haute de l'axe du vilebrequin
  H = new PVector( 0, P1.y);
  P1_M = PVector.dist(P1, M);
  L = PVector.dist(P1, P2);  // longueur de bielle droite
  P1.rotate(-PI/RPM);
}

void draw() {
  scale(1.5);
  background(255);
  translate(200, 300);
  strokeWeight(.01);
  stroke(0);
  //axes
  ellipse(0, 0, l1*2, l1*2); // course maneton vilebrequin
  line(0, 70, 0, -150);  // axe vertical vilebrequin
  line(70, 0, -70, 0);  //  axe horizontal vilebrequin
  line(70, -X, -70, -X);  //  axe horizontal pivot d'ailes

  strokeWeight(1);
  stroke(200, 20, 20);
  line(O.x, O.y, P1.x, P1.y); //course droite
  line(M.x, M.y, P2.x+Dec_Piv_aile, P2.y); // aile droite
  line(P1.x, P1.y, P2.x+Dec_Piv_aile, P2.y); //bielle
  line(O.x, O.y, v5.x, v5.y); //axe vertical vilebrequin
  ellipse(O.x, O.y, 5, 5);   // axe de vilebrequin
  ellipse(M.x, M.y, 5, 5);  // pivot d'aile droite
  ellipse(P2.x+Dec_Piv_aile, P2.y, 5, 5); // connection bielle - aile droite
  ellipse(P1.x, P1.y, 5, 5);  // articulation maneton bielle droite

  angle = PVector.angleBetween(P1, M); // angle entre le manneton et la ligne centre vilo_pivot d'aile
  Theta_1= (degrees(angle));
  println (degrees(angle));

  print("P1_M  = ");
  println(P1_M);

  A = flag*-acos((-sq(l1) + sq(P1_M) + sq(X)) / (2 * P1_M * X)) ;
  C = acos((sq(l2) + sq(P1_M) - sq(L)) / (2 * P1_M * l2)) ;

  if (P1.x > 0 ) {
    flag = 1;
    Theta_2 =  degrees(PI-((A)-(C)));
    Theta_2_2 =degrees((Theta_2-180)/1042/PI);
    println("ok1");
  } else {
    flag = -1;
    Theta_2 =  degrees(PI-((A)-(C)));
    //    Theta_2 =  degrees(PI+((C)+(A)));
    Theta_2_2 =degrees((Theta_2-180)/1042/PI);
    println("ok2");
  }

  y = cos(Theta_2_2)*l2;  //coordonnée x du point p2
  x = sin(Theta_2_2)*l2;  //coordonnée y du point p2

  stroke(#6282FA);//bleu
  ellipse(x, -X, 5, 5); // point P2
  stroke(#FC96FC); //rose
  ellipse(0, y-X, 5, 5);
  stroke(#FFAF2E); //orange
  ellipse(x, y-X, 5, 5);
  stroke(#62FA75); //vert
  H.y=P1.y;
  ellipse(H.x, H.y, 2, 2); // point H

  P1.rotate(-PI/RPM);  //rotation du vilebrequin
  P1_M = PVector.dist(P1, M);

  P2.x=x;
  P2.y=y-X;

  println(degrees(A)+", "+degrees(C));
  print("Theta_2 : ");
  println((Theta_2));
  print("Theta_1      : ");
  println((Theta_1));  
  print("Theta_2_test : ");
  println(Theta_2_test);
  print(" P1_M  = ");
  println(P1_M);
  print("bielle           : ");
  println(L);
  println("bielle Effective : "+PVector.dist(P1, P2));
  println(flag*degrees(angle));
  println("x = "+x+"; y = "+y);
  println(P1);
  println(P2);
  println();
  println();
}


Si quelqu'un à une idée pour corriger tout cela...  :smiley-mr-green:
Pas d'aide par MP !!!

Concernant le fonctionnement du forum tout se trouve dans les messages épinglés en tête de page.

jfs

J'ai eu de l'aide sur le forum de la fondation Processing.

Par contre il subsiste toujours le problème avec le décentrage du pivot de l'aile.

Code: [Select]

float l1 = 20;  // >> course
float l2 = 40; // distance bielle pivot d'aile >> Maneton_aile
float Bielle=0;  // longueur de la bielle
float Decalage_Maneton = 40;  // angle de décalage entre deux mannetons
float Dec_Piv_aile =20;  //distance du pivot de l'aile depuis l'axe
float X=75;
float angle=0;
float angle_Pivot = 0 ;
float angle_P1 = 0 ;
float Theta_2 = 0;
float Theta_2_test = 0;
float Theta_1 = 0;
float Theta_2_2 =0;
float P1_M = 0;
float O_M = 0;
float L = 0;
float flag = 1;
float A = 0;
float C = 0;
float x = 0 ;
float y = 0 ;
float RPM = 360; //360; // vitesse de rotation

int i = 0;

PVector  O, P1, M, P2, v5, H;

boolean dbug = false;
float dgx=0.0;

void setup() {
  size(600, 600); //,P2D);
  frameRate(40);
  background(255);
  strokeWeight(.2);
  stroke(0);
  noFill();
  smooth();
  O = new PVector(0, 0); //centre du vilebrequin
  P1 = new PVector( l1, 0);  //maneton
  // M = new PVector( Dec_Piv_aile, -Dist_Pivot_Vilo); //pivot de l'aile
  M = new PVector( 0+Dec_Piv_aile, -X); //pivot de l'aile
  // P2 = new PVector( l2 + Dec_Piv_aile , -Dist_Pivot_Vilo);  // jonction bielle - aile
  P2 = new PVector( l2, -X);  // jonction bielle - aile ///// possibilité de changer la position au départ en changeant "y"
  v5 = new PVector(0, -50); //valeur haute de l'axe du vilebrequin
  H = new PVector( 0, P1.y);
  P1_M = PVector.dist(P1, M);
  O_M = PVector.dist(O, M);
  L = PVector.dist(P1, P2);  // longueur de bielle droite
  //P1.rotate(-PI/RPM);
 
  println(" press key [space] for print ");
}



void do_calc() {
  angle = degrees(PVector.angleBetween(P1, v5)); // angle entre le manneton et le pivot d'aile
  angle_Pivot = degrees(PVector.angleBetween(v5, M)); // angle entre centre du vilebrequi et le pivot d'aile
  angle_P1 = degrees(PVector.angleBetween(v5, P1)); // angle entre le manneton et le centre du vilebrequin
  Theta_1= angle;
 

  if (P1.x < 0 )  angle_P1= -angle_P1;  //_______________________________________ change
 // else            flag = -1;
 
  if ( angle_P1-angle_Pivot > 0) flag =  1;  //_______________________________________ add
  else                           flag = -1;  //_______________________________________ add
 println(angle_Pivot);
println(angle_P1);
println (flag);
println();
println();
  A = flag*-acos((-sq(l1) + sq(P1_M) + sq(O_M)) / (2 * P1_M * O_M)) ;
  C = acos((sq(l2) + sq(P1_M) - sq(L)) / (2 * P1_M * l2)) ;
  Theta_2 =  degrees(PI-((A)-(C)));
  Theta_2_2 =  Theta_2-180;        //degrees((Theta_2-180)/1042/PI);   

  y = cos(radians(Theta_2_2))*l2;  //coordonnée x du point p2         
  x = sin(radians(Theta_2_2))*l2;  //coordonnée y du point p2         
 
  H.y=P1.y;

  P1.rotate(-PI/RPM);  //rotation du vilebrequin
  P1_M = PVector.dist(P1, M);

  P2.x=x;
  P2.y=y-75;
 
}

void draw() {
    //scale(1.5);     
  //  background(255);
  do_calc();           

  noStroke();
  fill(200, 200, 0);
  rect(0, 0, 600, 30);
  fill(0, 200, 0);
  rect(100, 120, 200, 300);
  fill(0);
 
  if (dbug) text("P1_M: = "+nf(P1_M, 1, 1)+" angle: "+nf(degrees(angle), 3, 1)+" A: "+nf((A), 1, 3)+" C: "+nf((C), 1, 3)+" Theta_2_2: "+nf((Theta_2_2), 3, 1), 20, 20);
  noFill();

  translate(200, 300);
  //  strokeWeight(.01);
  stroke(0);
  //axes
  ellipse(0, 0, l1*2, l1*2); // course maneton vilebrequin
  //ellipse(M.x, -X, l2*2, l2*2); // course maneton d'aile
  line(0, 70, 0, -150);  // axe vertical vilebrequin
  line(70, 0, -70, 0);  //  axe horizontal vilebrequin
  line(70, -X, -70, -X);  //  axe horizontal pivot d'ailes

  strokeWeight(1);
  stroke(200, 20, 20);
  line(O.x, O.y, P1.x, P1.y); //course droite
  line(M.x, M.y, P2.x+Dec_Piv_aile, P2.y); // aile droite  //_______________________________________ change
  line(P1.x, P1.y, P2.x+Dec_Piv_aile, P2.y); //bielle      //_______________________________________ change
  line(O.x, O.y, v5.x, v5.y); //axe vertical vilebrequin
  ellipse(O.x, O.y, 5, 5);   // axe de vilebrequin
  ellipse(M.x, M.y, 5, 5);  // pivot d'aile droite
  ellipse(P2.x+Dec_Piv_aile, P2.y, 5, 5); // connection bielle - aile droite     //_______________________________________ change
  ellipse(P1.x, P1.y, 5, 5);  // articulation maneton bielle droite


  stroke(#6282FA);//bleu
  ellipse(x, -X, 5, 5); // point P2
  stroke(#FC96FC); //rose
  ellipse(0, y-X, 5, 5); 
  //_______________________________________add as graph
  stroke(255);
  line(100+dgx+1, -150, 100+dgx+1, 150);  // clean up
  stroke(#FC96FC); //rose
  ellipse(100+dgx, y-X, 1, 1);  // KLL as graph

  stroke(#FFAF2E); //orange
  ellipse(x, y-X, 5, 5);
  stroke(#62FA75); //vert
  ellipse(H.x, H.y, 5, 5); // point H
  // KLL as graph
  ellipse(100+dgx, H.y, 1, 1);  // KLL as graph
  dgx+=0.3;
  if ( dgx > width/2 ) dgx = 0;  // next pix

  if (dbug) {  //_______________________________________add
    println("calc P1_M: P1_M "+nf(P1_M, 1, 1)+" P1 "+P1+" M "+M);
    println(degrees(A)+", "+degrees(C));
    print("Theta_2 : ");
    println((Theta_2));
    print("Theta_1      : ");
    println((Theta_1)); 
    print("Theta_2_test : ");
    println(Theta_2_test);
    print(" P1_M  = ");
    println(P1_M);
    print("bielle           : ");
    println(L);
    println("bielle Effective : "+PVector.dist(P1, P2));
    println(flag*(angle));
    println("x = "+x+"; y = "+y);
    println(P1);
    println(P2);
    println();
    println();
  }
}

void keyReleased(){ //_______________________________________add
 if (key == ' ') dbug=!dbug; 
}


Selon la formule usuelle.... si quelqu'un a une idée  :D
Pas d'aide par MP !!!

Concernant le fonctionnement du forum tout se trouve dans les messages épinglés en tête de page.

jfs

Bon.... j'arrive pas à faire que la bielle bleue ne soit pas élastique.

Si quelqu'un peut m'aider à trouver une solution.

Avec les sliders on peut régler la vitesse de rotation, la distance entre les pivot des ailes, la longueur des ailes et de la course du vilebrequin ainsi que le décalage des manetons....
Pas d'aide par MP !!!

Concernant le fonctionnement du forum tout se trouve dans les messages épinglés en tête de page.

lesept

Ça a pas l'air simple ton projet, je ne peux guère t'aider, juste t'encourager :)
A force d'essayer on finit par réussir... Donc, plus ça rate, plus on a de chances que ça marche (proverbe Sharduinok).

Artouste

Bon.... j'arrive pas à faire que la bielle bleue ne soit pas élastique.

Si quelqu'un peut m'aider à trouver une solution.

Avec les sliders on peut régler la vitesse de rotation, la distance entre les pivot des ailes, la longueur des ailes et de la course du vilebrequin ainsi que le décalage des manetons....
:smiley-mr-green:

Salut JF


[HUM]
Déjà , on ne dit pas la bielle bleue , mais "la belle bleue "  (expression populaire française)  souvent entendues les 14 juillets :
Quote
'Ho! , la belle bleue" , souvent suivie ou précédée par Ha! label rouge
:smiley-lol:



Retour sérieux



Tu devrais AMHA , plutôt exposer ta question sur un "forum" dédié méca/physique

jfs

Tu devrais AMHA , plutôt exposer ta question sur un "forum" dédié méca/physique
Le coté math et méca est plus ou moins résolu, la b(i)elle rouge fonctionne bien, c'est pour le coté gauche pour lequel je n'arrive pas à m'en sortir.... et je suis convaincu que c'est une simple question de logique avec les compensations d'angles, mais je commence à avoir le syndrome "halloween" : la tête comme une citrouille   :smiley-mr-green:
Pas d'aide par MP !!!

Concernant le fonctionnement du forum tout se trouve dans les messages épinglés en tête de page.

Artouste

Le coté math et méca est plus ou moins résolu, la b(i)elle rouge fonctionne bien, c'est pour le coté gauche pour lequel je n'arrive pas à m'en sortir.... et je suis convaincu que c'est une simple question de logique avec les compensations d'angles, mais je commence à avoir le syndrome "halloween" : la tête comme une citrouille   :smiley-mr-green:
Je vais bien trouver un pc semaine prochaine pour installer Processing
au moins je verrais comment ça bat (mal) de l'aile 8)

jfs

Pas d'aide par MP !!!

Concernant le fonctionnement du forum tout se trouve dans les messages épinglés en tête de page.

Artouste

Le coté math et méca est plus ou moins résolu, la b(i)elle rouge fonctionne bien, c'est pour le coté gauche pour lequel je n'arrive pas à m'en sortir.... et je suis convaincu que c'est une simple question de logique avec les compensations d'angles, mais je commence à avoir le syndrome "halloween" : la tête comme une citrouille   :smiley-mr-green:
Salut JF
Installé processing 3.4
aprés avoir un peu tatonné  pour savoir comment/où  m'en m'en sortir avec controlP5 et la localisation des "do calc" ;)
finalement , çà a fini "par causer dans le poste"  :smiley-mr-green:



Tu peux expliquer plus longuement ce qui  spécifiquement "te chagrine/perturbe" ?   8)

jfs

Le coté rouge (à droite) fonctionne, la valeur de la bielle est affichée en bas et varie de manière acceptable, si on tourne lentement la variation est très faible.
Si on change les paramètres, longueur des différents éléments, ou si on éloigne le pivot de l'aile du centre de l'ensemble ça fonctionne toujours du coté rouge.

Du coté bleu, (à gauche, la bielle est élastique et l'ensemble ne fonctionne que si le maneton n'est pas décalé par rapport au rouge et que le pivot de l'aile est au centre. C'est la seule configuration dans laquelle cela fonctionne.

Si on change un paramètre, la rotation du maneton et le levé de l'aile ne sont plus synchrone .... et j'aimerais que le coté bleu fonctionne comme le rouge pour pouvoir jouer avec le déplacement du maneton bleu et voir le décalage du mouvement des ailes produit par l'écartement des manetons du vilebrequin.
Pas d'aide par MP !!!

Concernant le fonctionnement du forum tout se trouve dans les messages épinglés en tête de page.

Artouste

Le coté rouge (à droite) fonctionne, la valeur de la bielle est affichée en bas et varie de manière acceptable, si on tourne lentement la variation est très faible.
Si on change les paramètres, longueur des différents éléments, ou si on éloigne le pivot de l'aile du centre de l'ensemble ça fonctionne toujours du coté rouge.

Du coté bleu, (à gauche, la bielle est élastique et l'ensemble ne fonctionne que si le maneton n'est pas décalé par rapport au rouge et que le pivot de l'aile est au centre. C'est la seule configuration dans laquelle cela fonctionne.

Si on change un paramètre, la rotation du maneton et le levé de l'aile ne sont plus synchrone .... et j'aimerais que le coté bleu fonctionne comme le rouge pour pouvoir jouer avec le déplacement du maneton bleu et voir le décalage du mouvement des ailes produit par l'écartement des manetons du vilebrequin.
Je lirais (plus mieux  :smiley-mr-green: ) mercredi ou jeudi
A chaud , je pencherais pour un/des moments isochrones perdus dans le rendu soft cinématique
Débordement de valeurs  , DIV 0  , etc  ?

jfs

Pas d'aide par MP !!!

Concernant le fonctionnement du forum tout se trouve dans les messages épinglés en tête de page.

Artouste

J'ai trouvé....  :D
8)

C'est bien , mais c'est un peu "laconique" comme réponse

Go Up