Arduino Forum

International => Français => Le bar => Topic started by: jfs on Nov 04, 2018, 07:03 pm

Title: [Processing3] visualiseur d'embiellage pour ailes battantes.
Post by: jfs on Nov 04, 2018, 07:03 pm
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++;
}
Title: Re: [Processing3] visualiseur d'embiellage pour ailes battantes.
Post by: jfs on Nov 04, 2018, 07:55 pm
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/ (https://www.lucidarme.me/transmission-par-bielles/)
Title: Re: [Processing3] visualiseur d'embiellage pour ailes battantes.
Post by: jfs on Nov 11, 2018, 08:32 pm
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:
Title: Re: [Processing3] visualiseur d'embiellage pour ailes battantes.
Post by: jfs on Nov 13, 2018, 07:49 am
J'ai eu de l'aide sur le forum de la fondation Processing (https://discourse.processing.org/t/connectingrods-and-crankshaft-for-flapping-bird/5186).

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
Title: Re: [Processing3] visualiseur d'embiellage pour ailes battantes.
Post by: jfs on Nov 25, 2018, 09:15 pm
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....
Title: Re: [Processing3] visualiseur d'embiellage pour ailes battantes.
Post by: lesept on Nov 25, 2018, 09:59 pm
Ça a pas l'air simple ton projet, je ne peux guère t'aider, juste t'encourager :)
Title: Re: [Processing3] visualiseur d'embiellage pour ailes battantes.
Post by: Artouste on Nov 25, 2018, 10:02 pm
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
Title: Re: [Processing3] visualiseur d'embiellage pour ailes battantes.
Post by: jfs on Nov 25, 2018, 10:09 pm
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:
Title: Re: [Processing3] visualiseur d'embiellage pour ailes battantes.
Post by: Artouste on Nov 25, 2018, 10:47 pm
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)
Title: Re: [Processing3] visualiseur d'embiellage pour ailes battantes.
Post by: jfs on Nov 25, 2018, 10:50 pm
ça bat (mal)
On dit Batman....
Title: Re: [Processing3] visualiseur d'embiellage pour ailes battantes.
Post by: Artouste on Nov 26, 2018, 08:43 pm
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)
Title: Re: [Processing3] visualiseur d'embiellage pour ailes battantes.
Post by: jfs on Nov 26, 2018, 09:23 pm
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.
Title: Re: [Processing3] visualiseur d'embiellage pour ailes battantes.
Post by: Artouste on Nov 26, 2018, 09:52 pm
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  ?
Title: Re: [Processing3] visualiseur d'embiellage pour ailes battantes.
Post by: jfs on Nov 29, 2018, 05:53 pm
J'ai trouvé....  :D
Title: Re: [Processing3] visualiseur d'embiellage pour ailes battantes.
Post by: Artouste on Nov 29, 2018, 07:35 pm
J'ai trouvé....  :D
8)

C'est bien , mais c'est un peu "laconique" comme réponse
Title: Re: [Processing3] visualiseur d'embiellage pour ailes battantes.
Post by: jfs on Nov 29, 2018, 08:16 pm
C'est pour le suspens.... ;D  :smiley-twist:
Title: Re: [Processing3] visualiseur d'embiellage pour ailes battantes.
Post by: jfs on Nov 29, 2018, 08:41 pm
En gros, je faisais faire un décalage au maneton de la partie gauche.... seulement je le faisais uniquement dans la partie graphique, la partie calcul utilisait toujours les même références.  :smiley-mr-green:

Les parties modifiées sont signalées avec les tirets en commentaires dans le fichier principal.

::)
Title: Re: [Processing3] visualiseur d'embiellage pour ailes battantes.
Post by: Artouste on Nov 29, 2018, 10:36 pm
En gros, je faisais faire un décalage au maneton de la partie gauche.... seulement je le faisais uniquement dans la partie graphique, la partie calcul utilisait toujours les même références.  :smiley-mr-green:

Les parties modifiées sont signalées avec les tirets en commentaires dans le fichier principal.

::)
Par pure curiosité ET quand j'aurais un moment , je vais regarder le résultat
parce que pour etre trés franc , je n'avais pas "bien vu" dans l'animation où etait le "soucis" initial
Title: Re: [Processing3] visualiseur d'embiellage pour ailes battantes.
Post by: jfs on Dec 06, 2018, 08:36 pm
https://youtu.be/eFuQP5K-Tqw (https://youtu.be/eFuQP5K-Tqw)

 ;)  :D
Title: Re: [Processing3] visualiseur d'embiellage pour ailes battantes.
Post by: dfgh on Dec 24, 2018, 08:37 pm
hello

j'avais vu ton post, mais là ou j'étais, je ne disposais pas de Processing.

aujourd'hui, j'ai pu exécuter ton prg.

tout d'abord, bravo pour le programme. en jouant avec on comprend bien ou se situe l'importance des écartements des manetons et des longueurs des bras de leviers.

sur le net, j'ai trouvé cette vidéo qui illustre parfaitement le résultat.
nota: à 1mn et 10 s, on voit bien le mécanisme .

l'oiseau qui vole (ultra léger) (https://lelombrik.net/17726)
Title: Re: [Processing3] visualiseur d'embiellage pour ailes battantes.
Post by: jfs on Dec 24, 2018, 08:45 pm
Oui, on voit bien l'importance des dimensions pour la synchro et suivant les limites qu'on dépasse ça devient "artistique" ....  :D

J'ai encore pas mal de choses à rajouter et modifier pour que ce soit vraiment utilisable dans le cadre que j'envisage.