Kinetic little rain

1
2//#include <Tic.h>// pas besoin de cette bibliotheque , car je gère  l'écriture des bytes moi-même
3
4#ifdef SERIAL_PORT_HARDWARE_OPEN
5#define  ticSerial SERIAL_PORT_HARDWARE_OPEN
6#else
7#include <SoftwareSerial.h>
8SoftwareSerial  Serial1(18, 19); //pour arduino 2560 18 tx sur arduino (transmet)  pour rx (reçois)sur  le tic
9#endif
10
11
12#define swap(a,b){int t=a;a=b;b=t;}//utilisé pour dessiner  une ligne
13//TicSerial tic1000(ticSerial, 1000); pas besoin de créer un objet  de ce type car je n'utilise plus la bibliotheque tic.h
14
15// numéro des commandes  utilisées
16uint8_t haltandsetposition=0xEC;
17uint8_t setmaxspeed=0xE6;
18uint8_t  settargetposition=0xE0;
19uint8_t setmaxacceleration=0xEA;
20uint8_t setmaxdecceleration=0xE9;
21//uint8_t  setstepmode=0x94;//0 =full;1=1/2, 2=1/4,  3=1/8
22//*******************
23float  target[100];
24float targetpreced[100];
25float targetprochain[100];
26float  grandeurtrajet[100];
27unsigned long tabtiming[100];
28bool tabmontil[100];
29float  targetpossup[100];
30float targetposinf[100];
31
32float trajetleplusgrand=0;
33float  vitesselaplusgrande=0;
34float frax=0.3; // c'est la fraction du temps pour faire  le trajet pendant laquelle ça acceélere ou decellere
35float ac=10000;// acceleration
36int  nummoteur=0;
37float vitessemax=10000000;
38float d=0;
39float d2=0;
40float  v=0;// vitesse
41float tempsdutrajet=1;// est aussi defini par le bluetooth en  envoyant depuis le natel t=2.5#
42float alpha=0;
43float alphaincr=0.3;// est  aussi defini par le bluetooth en envoyant depuis le natel a=0.4#
44float beta=0;
45float  betaincr=0.1;
46float gamma=0;
47float gammaincr=0.1;
48bool count=true;
49bool  count2=true;
50unsigned long t;
51unsigned long tprecedent;
52int laps1;
53int  laps2;
54int incr=0;
55
56float tinter=0;
57float tinter2=0;
58
59int endroit=4000;
60float  parametre=0.1;
61
62int nbrdefois=0;
63int dernieregoutte=0;
64int tempspourremonter=10;
65unsigned  long longueuronde=20;
66//*******************
67// pour le bluetooth
68String  msg="";
69
70const byte numChars = 32;
71char receivedChars[numChars];
72char  tempChars[numChars];        // temporary array for use when parsing
73char messageFromPC[numChars]  = {0};// variables to hold the parsed data
74String messagerecu="";
75float  integer0FromPC = 0;
76
77boolean newData = false;
78
79
80
81
82
83
84//  dans l'app pololu mettre max accelartion à 1000000(1 milion, c'est super réactif);  mais c'est tres saccadé préféré 200000
85// idéalement il faudrait calculé le temps  exact avec l'acceleration 
86
87// et votesse max à 100000000 ( 100 milion)
88void  setup()
89{
90  Serial.begin(115200);// pour le moniteur
91  Serial1.begin(115385);//  serial1 permet d'écrire les bytes dans les moteurs
92  Serial2.begin(9600); //pour  le bluetooth pin 16 17
93
94
95  // Give the Tic some time to start up.
96  delay(20);
97
98  // Set the Tic's current position to 0, so that when we command
99  // it to  move later, it will move a predictable amount.
100  //  // Tells the Tic that it  is OK to start driving the motor.  The
101//  // Tic's safe-start feature helps  avoid unexpected, accidental
102//  // movement of the motor: if an error happens,  the Tic will not
103//  // drive the motor again until it receives the Exit Safe  Start
104//  // command.  The safe-start feature can be disbled in the Tic
105
106
107  for (int i=0;i<100;i++){
108  moteurplus(i,haltandsetposition,0);//haltandsetposition  avec plus de 127 moteurs
109 exitsafedebut(i);//exitsafestart avec plus de 127 moteurs,  si il y a une coupure de courant par exemple le moteur ne redemarre pas sauf si  on utilie cette commande ou si dans
110 // dans le controlleur Tic on mette Disable  safe start
111   }
112
113
114 }
115
116
117 
118
119
120
121
122
123
124void loop()
125{
126
127if  (count==true){
128  count=false;
129
130remonteretmettreazero(20);// attendre 23  secondes
131}
132
133
134
135courbe();
136vaguepastoute();
137
138dessincourbe(15,6,6,2999);//  numéro de la courbe et temps du trajet en seconde et temps d'arret et parametre    // cercle 
139dessincourbe(15,6,6,-2999);// numéro de la courbe et temps du  trajet en seconde et temps d'arret et parametre    //cercle inversé
140dessincourbe(15,6,6,2999);//  numéro de la courbe et temps du trajet en seconde et temps d'arret et parametre    //cercle
141dessincourbe(15,6,6,-2999);// numéro de la courbe et temps du trajet  en seconde et temps d'arret et parametre    //cercle inversé
142dessincourbe(14,6,6,0);//  on remonte à zero tous en même tempsnuméro de la courbe et temps du trajet et temps  d'arret et parametre  // remonte tous
143remonteretmettreazero(2); // mettre à zero
144
145chute();
146vague();
147sinus();
148
149
150remonteretmettreazero(23);
151//chenille();
152
153//testmoteur(5000,0,0);
154//testmoteur(5000,0,1);
155
156
157
158controlbluetooth()  ; // ceci fonctionne si on veut recevoir dans une variable ce ui arrive du natel  format : texte=12#
159
160
161
162}
163
164
165
166/////////////*******************************************************************************
167
168void  testmoteur(int targetpos, int x,int y)
169
170{
171
172  for (int x=0;x<1;x++){
173    for (int y=0;y<10;y++){
174  nummoteur=x*10+y;
175   moteurplus(nummoteur,setmaxspeed,90000000);//
176    moteurplus(nummoteur,setmaxacceleration,1000000);
177 moteurplus(nummoteur,setmaxdecceleration,100000);  
178  moteurplus(nummoteur,settargetposition,targetpos);
179    }}
180delay(targetpos);
181  
182  for (int x=1;x<2;x++){
183    for (int y=0;y<10;y++){
184  nummoteur=x*10+y;
185   moteurplus(nummoteur,setmaxspeed,90000000);//
186    moteurplus(nummoteur,setmaxacceleration,1000000);
187  moteurplus(nummoteur,setmaxdecceleration,100000); 
188  moteurplus(nummoteur,settargetposition,targetpos);
189    }}
190delay(targetpos);
191
192for (int x=0;x<1;x++){
193    for (int y=0;y<10;y++){
194  nummoteur=x*10+y;
195 moteurplus(nummoteur,settargetposition,0);
196    }}
197delay(targetpos);
198
199  for (int x=1;x<2;x++){
200    for (int y=0;y<10;y++){
201  nummoteur=x*10+y;
202  moteurplus(nummoteur,settargetposition,0);
203    }}
204delay(targetpos);
205
206}
207/////////////*******************************************************************************
208
209void  positionmoteur(int targetpos)
210{
211// 1000 =15 cm en 1/4 de step ou 30 cm en  1/2 step
212//4000=60cm
213//8000=120cm
214if(targetpos>8000){targetpos=8000;}
215
216  for (int x=0;x<10;x++){
217    for (int y=0;y<10;y++){
218  nummoteur=x*10+y;
219   moteurplus(nummoteur,setmaxspeed,10000000);//
220    moteurplus(nummoteur,setmaxacceleration,100000);
221  moteurplus(nummoteur,setmaxdecceleration,10000); 
222 delay(1);
223  moteurplus(nummoteur,settargetposition,targetpos);
224
225}}
226
227
228
229}
230
231/////////////*******************************************************************************
232
233
234void  remonteretmettreazero(int delai)//delai en seconde
235{
236
237 for (int i=0;i<100;i++){
238  moteurplus(i,setmaxspeed,8000000);//9000000 
239 moteurplus(i,setmaxacceleration,100000);
240  moteurplus(i,setmaxdecceleration,100000); 
241 moteurplus(i,settargetposition,-23000);
242   }
243   
244//delaiavecbluetooth(23000);
245delay(delai*1000);
246for (int i=0;i<100;i++){
247  moteurplus(i,haltandsetposition,0);
248  exitsafedebut(i);
249  setstepmode(i,2);////0  =full;1=1/2, 2=1/4,  3=1/8
250  targetpreced[i]=0;
251
252}
253
254}
255/////////////*******************************************************************************
256
257void  courbe()
258{
259
260//
261dessincourbe(1,4.3,4.2,0);// numéro de la courbe et temps  du trajet en seconde et temps d'arret et parametre    // x2-y2
262dessincourbe(2,4,3.8,0);//  numéro de la courbe et temps du trajet et temps d'arret et parametre              //-(x2-y2)
263
264dessincourbe(5,5,4.9,0);//numéro  de la courbe et temps du trajet et temps d'arret et parametre           // sin(x/3)*sin(y/3)
265dessincourbe(6,5,4.9,0);//numéro  de la courbe et temps du trajet et temps d'arret et parametre            // // sin(x/3)*cos(y/3)
266dessincourbe(7,5,4.9,0);//numéro  de la courbe et temps du trajet et temps d'arret et parametre           // cos(x/3)*cos(y/3)
267
268dessincourbe(10,2.5,2.4,0);//  numéro de la courbe et temps du trajet et temps d'arret et parametre         //  x*y // vol oiseau
269dessincourbe(11,2.5,2.4,0);// numéro de la courbe et temps  du trajet et temps d'arret et parametre        //-(x*y)
270dessincourbe(10,2.5,2.4,0);//  numéro de la courbe et temps du trajet et temps d'arret et parametre         //  x*y
271dessincourbe(11,2.5,2.4,0);// numéro de la courbe et temps du trajet et temps  d'arret et parametre        //-(x*y)
272dessincourbe(12,3,2.8,0);// numéro de la  courbe et temps du trajet et temps d'arret et parametre         // -(x2+y2-2xy)
273dessincourbe(13,3,2.8,0);//  numéro de la courbe et temps du trajet et temps d'arret et parametre        //x2+y2-2xy
274dessincourbe(12,3,2.8,0);//  numéro de la courbe et temps du trajet et temps d'arret et parametre         //  -(x2+y2-2xy)
275dessincourbe(13,3,2.8,0);// numéro de la courbe et temps du trajet  et temps d'arret et parametre        //x2+y2-2xy// fin vol oiseau
276
277dessincourbe(3,5,4,0);//  numéro de la courbe et temps du trajet et temps d'arret et parametre            //  x2+y2//  bond et rebond
278dessincourbe(4,3,2.8,0);// numéro de la courbe et temps  du trajet et temps d'arret et parametre          // -(x2+y2)
279dessincourbe(3,3,2.8,0);//  numéro de la courbe et temps du trajet et temps d'arret et parametre         //  x2+y2
280dessincourbe(4,3,2.8,0);// numéro de la courbe et temps du trajet et temps  d'arret et parametre          // -(x2+y2)
281dessincourbe(3,3,3,0);// numéro de  la courbe et temps du trajet et temps d'arret et parametre         // x2+y2   /fin  de bon et rebond
282
283///////*************************** courbe 8
284  parametre=0.1;
285dessincourbe(8,5,5,parametre);  // numéro de la courbe et temps du trajet et temps d'arret et parametre // sin(x+y+parametre/3)
286for  (int i=0;i<50;i++){
287  parametre=parametre+0.5;
288dessincourbe(8,0.8,0.3,parametre);//numéro  de la courbe et temps du trajet et temps d'arret et parametre
289//ici de délai  d'attente est 0 car le temps de calcul est suffisant entre chaque intrscution donnée  toutes les 0.05 sec
290}
291
292///////***************************courbe 9
293
294  parametre=0.1;
295dessincourbe(9,5,8,parametre);// numéro de la courbe et temps  du trajet et temps d'arret et parametre // sin(x+parametre/)+sin(y+parametre/)+
296for  (int i=0;i<50;i++){
297  parametre=parametre+0.5;
298dessincourbe(9,0.8,0.3,parametre);//numéro  de la courbe et temps du trajet et temps d'arret et parametre
299
300//ici de délai  d'attente est 0 car le temps de calcul est suffisant entre chaque intrscution donnée  toutes les 0.01 sec
301//positionmoteur(5000);// 1000 =15 cm en 1/4 de step // 1000  =15 cm en 1/4 de step ou 30 cm en 1/2 step//4000=60cm//8000=120cm
302}
303
304///////***************************  courbe 14 on remonte tout
305dessincourbe(14,6,6,0);// on remonte à zero tous en  même tempsnuméro de la courbe et temps du trajet et temps d'arret et parametre 
306
307remonteretmettreazero(2);
308
309}//  fin de courbe
310
311
312/////////////*******************************************************************************
313void  dessincourbe(int numerodessin,  float temps, float tempsdelai,float parametre)
314{
315
316//calcul  de la prochaine position
317float kapa=0;//pour le dessin no 15
318  
319 for (int  x=0;x<10;x++){
320    for ( int y=0;y<10;y++){
321      nummoteur=x*10+y;
322
323if(numerodessin==1){
324    target[nummoteur]=3000-60*((x-5)*(x-5)-(y-5)*(y-5));// donc un trajet au max  de 1000=15cm; 2000=30cm
325}
326
327if(numerodessin==2){
328    target[nummoteur]=5000+60*((x-5)*(x-5)-(y-5)*(y-5));//  donc un trajet au max de 1000=15cm; 2000=30cm
329   }
330if(numerodessin==3){
331    target[nummoteur]=3500-70*((x-5)*(x-5)+(y-5)*(y-5));// donc un trajet au max  de 1000=15cm; 2000=30cm
332}
333
334if(numerodessin==4){
335    target[nummoteur]=4500+70*((x-5)*(x-5)+(y-5)*(y-5));//  donc un trajet au max de 1000=15cm; 2000=30cm
336   }
337   
338if(numerodessin==5){
339  float t=x-5;
340  float u=y-5;
341    target[nummoteur]=4000+2000*sin(t/3)*sin(u/3);//  donc un trajet au max de 1000=15cm; 2000=30cm
342   }
343   
344if(numerodessin==6){
345  float t=x-5;
346  float u=y-5;
347    target[nummoteur]=4000+2000*cos(t/3)*sin(u/3);//  donc un trajet au max de 1000=15cm; 2000=30cm
348   }
349   
350   if(numerodessin==7){
351  float t=x-5;
352  float u=y-5;
353    target[nummoteur]=4000+2000*cos(t/3)*cos(u/3);//  donc un trajet au max de 1000=15cm; 2000=30cm
354   }
355
356   if(numerodessin==8){
357  float t=x-5;
358  float u=y-5;
359    target[nummoteur]=4000+2000*sin((t+u+parametre)/3);//  donc un trajet au max de 1000=15cm; 2000=30cm
360   }
361
362   if(numerodessin==9){
363  float t=x-5;
364  float u=y-5;
365    target[nummoteur]=4000+1500*(sin((t+parametre)/2)+sin((u+parametre)/2));//  donc un trajet au max de 1000=15cm; 2000=30cm
366   }
367
368  if(numerodessin==10){
369  float t=x-5;
370  float u=y-5;
371    target[nummoteur]=4000+100*t*u;// donc un  trajet au max de 1000=15cm; 2000=30cm
372   }
373  if(numerodessin==11){
374  float  t=x-5;
375  float u=y-5;
376    target[nummoteur]=5000-100*t*u;// donc un trajet  au max de 1000=15cm; 2000=30cm
377   }
378  if(numerodessin==12){
379  float t=x-5;
380  float u=y-5;
381    target[nummoteur]=5000-40*(t*t+u*u-2*t*u);// donc un trajet  au max de 1000=15cm; 2000=30cm
382   }
383  if(numerodessin==13){
384  float t=x-5;
385  float u=y-5;
386    target[nummoteur]=4000+40*(t*t+u*u-2*t*u);// donc un trajet  au max de 1000=15cm; 2000=30cm
387   }
388
389 if(numerodessin==14){// on remonte  à 0 en même temps
390  target[nummoteur]=0;
391   }
392
393
394if(numerodessin==15){
395    target[nummoteur]=3000+parametre*sin(kapa);// donc un trajet au max de 1000=15cm;  2000=30cm// cercle
396    kapa=kapa+0.31415;
397   
398}
399
400
401
402   
403
404if(target[nummoteur]>8000){target[nummoteur]=8000;}//pour  ne pas aller trop bas
405
406grandeurtrajet[nummoteur]=abs(target[nummoteur]-targetpreced[nummoteur]);
407}}
408
409
410
411//calcul  de la vitesse pour y arriver tous en même temps
412for (int i=0;i<100;i++){
413calculvitesseetacc  (temps,grandeurtrajet[i], 0.15);
414
415moteurplus(i,setmaxspeed,v); 
416moteurplus(i,setmaxacceleration,ac);
417moteurplus(i,setmaxdecceleration,ac);  
418 delayMicroseconds(10);
419//nepas mettre ici  moteurplus(i,settargetposition,target[i]);  car le delay de 10ms fait qu'il y a un petit decalage dans les gouttes
420}
421
422
423for  (int i=0;i<100;i++){
424moteurplus(i,settargetposition,target[i]);
425targetpreced[i]=target[i];
426//delay(2);//  voir si vrament utile
427}
428
429delay(tempsdelai*1000);
430//delaiavecbluetooth(tempsdelai*1000);  ne fonctionne pas bien les gouttes desscendent trop bas
431
432
433
434
435}
436
437
438
439
440
441/////////////*******************************************************************************
442void  sinus()
443
444{
445//1 pulse/seconde= vitesse 10000
446// pour faire un tour il  faut 200 pulse en full, 800 en 1/4
447// 1 tour de poulie environ 12 cm donc 800  pulse , 24 cm =1600 pulse
448 unsigned long dureeprogrammedepart=0;
449 
450 tempsdutrajet=0.5;  // est donné par le bluetooth t=1.5#    pas descendre en dessous de 0.5 secondes  sinon accout pour de long trajet
451 alpha=0;
452 beta=0;
453 alphaincr=0.1;//des  increment plus grand que 0.3 font des décalages entre les moteurs
454 betaincr=0.1;
455  gammaincr=0.2;
456 frax=0.40;// c'est à dire 40% dutrajet en acceleration; 20% en  vitesse constante et40% en deceleration, maximum c'est 0.5
457// en fait pour de  court trajet genre sinus (alpha =alpha+01, il faut mettre frax au minimum=0.001
458//ça  marche bien avec 0.2 et un délai plus court entre chaque salve de commande
459//  a= Path/(t au carré *frax*(1-frax))
460// a*t*frax=v
461
462
463
464if (count2==true){
465  count2=false;
466//pour amener les gouttes au bon endroit avant de lancer sinus
467    for (int x=0;x<10;x++){
468    for (int y=0;y<10;y++){
469  nummoteur=x*10+y;
470   moteurplus(nummoteur,setmaxspeed,9000000);//
471    moteurplus(nummoteur,setmaxacceleration,100000);
472  moteurplus(nummoteur,setmaxdecceleration,100000); 
473  
474target[nummoteur]=4000+3000*sin(alpha+x*betaincr+y*0.2);//  donc un trajet au max de 1600+1550=3150/800=3.9X12cm=47cm
475
476if(target[nummoteur]>8000){target[nummoteur]=8000;}//pour  ne pas aller trop bas
477  
478  moteurplus(nummoteur,settargetposition,target[nummoteur]);
479targetpreced[nummoteur]=target[nummoteur];
480}}
481delay(10000);
482}
483
484
485dureeprogrammedepart=millis();
486
487while(millis()<dureeprogrammedepart+120000){//  durée de 3 minutes
488 Serial.println(millis()/1000);
489//calcul de la prochaine  position
490  for (int x=0;x<10;x++){
491    for (int y=0;y<10;y++){
492  nummoteur=x*10+y;
493  target[nummoteur]=4000+3000*sin(alpha+x*betaincr+y*0.2);// donc un trajet au max  de 1000=15cm; 2000=30cm
494  //Serial.print("x  :");Serial.print(x);Serial.print("  y  :");Serial.print(y);Serial.print("  target  :");Serial.println( target[nummoteur]);
495  if(target[nummoteur]>8000){target[nummoteur]=8000;}//pour ne pas aller trop bas
496
497  grandeurtrajet[nummoteur]=abs(target[nummoteur]-targetpreced[nummoteur]);
498  }
499}
500
501betaincr=betaincr+0.003;
502alpha=alpha+alphaincr;
503
504//calcul  de la vitesse pour y arriver tous en même temps
505for (int i=0;i<100;i++){
506
507calculvitesseetacc  (tempsdutrajet,grandeurtrajet[i], frax);// calcul de la vitesse et de l'accelerationn  en fonction du temps du rajet de la longueure du trajet et du % d'acceleration 
508
509moteurplus(i,setmaxspeed,v);  
510moteurplus(i,setmaxacceleration,ac);
511moteurplus(i,setmaxdecceleration,ac);  
512moteurplus(i,settargetposition,target[i]);
513targetpreced[i]=target[i];
514delayMicroseconds(1000);
515  
516}
517
518
519d2=(tempsdutrajet)*1000;
520incr=incr+1;
521t=millis();
522laps1=t-tprecedent;//  temps entre deux série d'envoi de commande (pour les 100 moteurs)sur les tics
523tprecedent=t;
524//  idélalement laps1 devrait être égale au tempsdutrajet , mais ça ne l'est pas car  le fait de mettre un délai=au tempsdutrajet s'ajoute encore le temps ppur executer  toutes les instrcution
525// donc il faut diminuer le délai
526if(incr==2){// avant  j'avais mis 3 mais ça fait buger les moteurs ????????
527  laps2=laps1;
528 laps2=laps2-(tempsdutrajet)*600;  // 700 au lieu de 1000 pour prndre le 70% de la durée du trajet
529 
530 if(laps2>d2){laps2=d2;}
531}
532delay(d2-laps2);
533
534}
535  remonteretmettreazero(20);
536}
537
538/////////////*******************************************************************************
539
540
541void  vague()
542{ 
543  
544float targetinf=4000;
545float targetsup=1000;
546
547 unsigned  long tempsdepart=0;// timing de l'arduino au début, il faut un unsigned long sinon  millis ne fonctionne pas correctement
548    
549 unsigned long temps=0;//  en ms  la première salve de gouttes partent au bout de 0 secondes
550 unsigned long tempsentregoutte=200;  //en ms , pas moins de 100ms 200 pose des problèmes
551 unsigned long longueuronde=15;  // demi longueure d'onde en goutte d'eau du prochain minimum
552// tempsdutrajet=longueuronde*tempsentregoutte/1000;//tempsdutrajet  en seconde
553int aa=1;
554int bb=0; //utiliser avec modulo
555int cc=1;
556int  dd=0;
557alpha=0;
558alphaincr=0.04;
559beta=0;
560betaincr=0.01;
561int nummoteur2=0;
562
563   // assignation de départ des gouttes
564  for (int x=0;x<10;x++){
565    for  (int y=0;y<10;y++){
566        assignationdepart(x,y,temps,4000,1000,true);// x,y,temps,  targetinf, targetsup, on commence par monter? true ou false
567   }
568  temps=temps+tempsentregoutte;//  la prochaine salve partira apres tant de ms
569  }
570  // fin d'assignation de  départ des gouttes
571nbrdefois=4;
572
573
574positionmoteur(targetinf);
575delay(7000);
576
577
578tempsdepart=millis();//  on prend le temps du départ
579
580while(aa<8){
581
582  for (int i=0;i<100;i++){//  on boucle pour chaque goutte, mais au moment de la première goutte on change au  bout d'un moment certain parametre
583
584
585if(millis()-tempsdepart>tabtiming[i]){  // faire comme ça plutôte que :if (millis()>tempsdepart+tabtiming[i] )   pour que  l'équation soit moins longue à traiter 
586
587// si on veut changer la longueure  d'onde en cours de route il faut recalculer le temps du trajet , la vitesse et l'acceleration
588//  le passage à une autre longueure d'onde ne se fait que lorsque on recommence avec  la première gouttequi avait démarer ici c'est la 0
589    
590if(i==0){ dd=dd+1;
591
592  if((dd==nbrdefois)&&(aa==1)){longueuronde=20;aa=2;dd=0;nbrdefois=2;}// 
593    
594  if((dd==nbrdefois)&&(aa==2)){longueuronde=15;aa=3;dd=0;nbrdefois=4;// croisement  de la moitié
595     for (int yy=0;yy<5;yy++){
596      for (int xx=0;xx<10;xx++){
597      nummoteur2=xx*10+yy;
598     
599 if(tabmontil[nummoteur2]==true){
600     tabmontil[nummoteur2]=false;}
601     else{
602     tabmontil[nummoteur2]=true;}}}}
603
604 if((dd==nbrdefois)&&(aa==3)){longueuronde=15;aa=4;dd=0;nbrdefois=3;//  fin de croisement 
605 for (int yy=0;yy<5;yy++){
606      for (int xx=0;xx<10;xx++){
607      nummoteur2=xx*10+yy;
608 if(tabmontil[nummoteur2]==true){
609     tabmontil[nummoteur2]=false;}
610     else{
611     tabmontil[nummoteur2]=true;}}}}
612 
613
614 if((dd==nbrdefois)&&(aa==4)){longueuronde=13;aa=5;dd=0;nbrdefois=2;//  plus bas
615     for (int jj=0;jj<100;jj++){
616    targetposinf[jj]=6000;}}
617   
618if((dd==nbrdefois)&&(aa==5)){longueuronde=16;aa=6;dd=0;nbrdefois=5;// croisememt
619     for (int jj=0;jj<100;jj++){
620     if(jj%2==0){
621     if(tabmontil[jj]==true){
622     tabmontil[jj]=false;}
623     else{
624     tabmontil[jj]=true; }
625      }}}
626     
627if((dd==nbrdefois)&&(aa==6)){longueuronde=16;aa=7;dd=0;nbrdefois=4;// arret  croisement     et changer la longueure d'onde la faire plus grande pour que ce soit  un peu plus lent 
628      for (int jj=0;jj<100;jj++){
629      if(jj%2==0){
630      if(tabmontil[jj]==true){
631      tabmontil[jj]=false;}
632      else{
633      tabmontil[jj]=true;}} } }
634
635if((dd==nbrdefois)&&(aa==7)){longueuronde=13;aa=8;dd=0;nbrdefois=2;  }
636//     for (int jj=0;jj<100;jj++){
637//    targetposinf[jj]=6000;}}
638      
639  //if((dd==nbrdefois)&&(aa==7)){longueuronde=16;aa=8;dd=0;nbrdefois=4; 
640//        //Serial.println(cc);  
641//     if(cc==5){aa=8;}// on fait ce bout 5x  ( ce qui fait qu'on passe 5x4=20x)
642//      if(bb%4==0){// on refait ce bout tous les 4x
643//        
644//      for  (int yy=0;yy<10;yy++){
645//      for (int xx=0;xx<10;xx++){
646//      nummoteur2=xx*10+yy;
647//      targetpossup[nummoteur2]=1500+1000*sin(alpha+beta);
648//      
649//      targetposinf[nummoteur2]=5000;
650//      beta=beta+betaincr;
651//      }
652//      alpha=alpha+alphaincr;}
653//    cc=cc+1;
654//   
655//      }
656//      bb=bb+1;
657//      }
658     
659       
660}
661
662tempsdutrajet=longueuronde*tempsentregoutte/1000;//tempsdutrajet  en seconde
663calculvitesseetacc (tempsdutrajet,targetposinf[i]-targetpossup[i],  0.15);// calcul de la vitesse et de l'accelerationn en fonction du temps du rajet  de la longueure du trajet et du % d'acceleration 
664 tabtiming[i]=tabtiming[i]+tempsdutrajet*1000;//  on repart ilfaut mettre cette instruction ici et non pas après l'envoi des commandes  de moteurs qui prennent un certain temps du coup certaines gouttes ont du retard
665
666
667  moteurplus(i,setmaxspeed,v);//
668 moteurplus(i,setmaxacceleration,ac);
669 moteurplus(i,setmaxdecceleration,ac);  
670//delayMicroseconds(1);// pas  variment necessaire
671 
672if(tabmontil[i]==true){
673  moteurplus(i,settargetposition,targetpossup[i]);
674  tabmontil[i]=false;
675  }
676
677 else{
678  moteurplus(i,settargetposition,targetposinf[i]);
679  tabmontil[i]=true;}
680  
681 
682
683
684}
685
686}
687
688
689}
690
691
692remonteretmettreazero(3);
693}
694
695
696
697
698/////////////*******************************************************************************
699
700
701void  vaguepastoute()
702{ 
703float targetinf=4000;
704float targetsup=1000;
705
706  unsigned long tempsdepart=0;// timing de l'arduino au début, il faut un unsigned  long sinon millis ne fonctionne pas correctement
707    
708 unsigned long temps=0;//  en ms la première salve de gouttes partent au bout de 0 secondes
709 unsigned  long tempsentregoutte=200; //en ms , pas moins de 100ms
710 //unsigned long longueuronde=20;  // demi longueure d'onde en goutte d'eau du prochain minimum 
711// tempsdutrajet=longueuronde*tempsentregoutte/1000;//tempsdutrajet  en seconde
712int aa=1;
713int bb=1; 
714int cc=1;
715
716int nummoteur2=0;
717
718
719
720while(bb<5){
721
722   // assignation de départ des gouttes      // dans les scénaris il faut encore  mettre le nbr de fois et la goutte qui est dernière et temps pour remonter à la  fin
723if(bb==1){scenario1departgoutte();}// nbrdefois=11; dernieregoutte=55; la  longieurd'onde peut être modifiée dans le scénario
724if(bb==2){scenario2departgoutte();}  
725if(bb==3){scenario3departgoutte();}
726if(bb==4){scenario4departgoutte(); }  
727  // fin d'assignation de départ des gouttes
728
729
730
731
732tempsdepart=millis();//  on prend le temps du départ
733
734while(aa<nbrdefois){
735  for (int i=0;i<100;i++){//  on boucle pour chaque goutte, mais au moment de la première goutte on change au  bout d'un moment certain parametre
736delayMicroseconds(1);// ça ne fonctionne pas  sinon
737
738if(millis()>tempsdepart+tabtiming[i]){
739
740// si on veut changer  la longueure d'onde en cours de route il faut recalculer le temps du trajet , la  vitesse et l'acceleration
741// le passage à une autre longueure d'onde ne se fait  que lorsque on recommence avec la première gouttequi avait démarer ici c'est la  0
742
743    
744if(i==dernieregoutte){aa=aa+1;//nbrdefois+1
745
746//if(bb==4){//scénario  4 on change le target inf à chaque fois
747// for (int y=0;y<10;y++){
748//    for  (int x=0;x<10;x++){
749//     nummoteur=x*10+y;
750//  targetpossup[nummoteur]=targetpossup[nummoteur]+y*50;
751//   //targetposinf[nummoteur]=targetposinf[nummoteur]-y*50;
752//  }}
753//}
754
755}//  fin de on compte nbr de fois
756
757
758
759tempsdutrajet=longueuronde*tempsentregoutte/1000;//tempsdutrajet  en seconde
760calculvitesseetacc (tempsdutrajet,targetposinf[i]-targetpossup[i],  0.15);// calcul de la vitesse et de l'accelerationn en fonction du temps du rajet  de la longueure du trajet et du % d'acceleration 
761
762 moteurplus(i,setmaxspeed,v);//
763  moteurplus(i,setmaxacceleration,ac);
764 moteurplus(i,setmaxdecceleration,ac); 
765delayMicroseconds(10);
766  
767if(tabmontil[i]==true){
768  moteurplus(i,settargetposition,targetpossup[i]);
769  tabmontil[i]=false;
770  }
771
772 else{
773  moteurplus(i,settargetposition,targetposinf[i]);
774  tabmontil[i]=true;}
775  
776  tabtiming[i]=tabtiming[i]+tempsdutrajet*1000;//  on repart
777
778
779}
780
781}
782
783}
784bb=bb+1;//scenario suivant
785aa=1;
786
787remonteretmettreazero(tempspourremonter);
788
789
790
791}
792
793}
794
795
796
797  
798//*******************************************************************
799void  chute()
800{
801 
802float targetinf=7000;
803float targetsup=0;
804
805 unsigned  long tempsdepart=0;// timing de l'arduino au début, il faut un unsigned long sinon  millis ne fonctionne pas correctement
806    
807 unsigned long temps=1000;//  en  ms la première salve de gouttes partent au bout de 0 secondes
808 unsigned long  tempsentregoutte=200; //en ms , pas moins de 100ms
809 //unsigned long longueuronde=20;  // demi longueure d'onde en goutte d'eau du prochain minimum 
810// tempsdutrajet=longueuronde*tempsentregoutte/1000;//tempsdutrajet  en seconde
811int nbrdefois=1;
812int a=0;
813int nummoteur=0;
814int tabordre[100];
815int  x1=0;
816int x2=0;
817int c=0;
818//scenario de chute
819
820
821 for(int ii=0;ii<100;  ii++) {
822tabordre[ii]=ii;// initilaistation du tableau de l'odre de depart
823targetposinf[ii]=targetinf;
824targetpossup[ii]=targetsup;
825tabmontil[ii]=false;
826
827}
828
829
830for(long  j=0;j<2560;j++){// on mélange le tableau
831 x1=random(0,100);
832 x2=random(0,100);
833c=tabordre[x1];
834tabordre[x1]=tabordre[x2];
835tabordre[x2]=c;
836}
837
838
839
840for(int  l=0;l<5; l++) {
841nummoteur=tabordre[l];
842temps=temps+1000;
843tabtiming[nummoteur]=temps;}
844
845for(int  l=5;l<20; l++) {
846nummoteur=tabordre[l];
847temps=temps+500;
848tabtiming[nummoteur]=temps;}
849
850for(int  l=20;l<30; l++) {
851nummoteur=tabordre[l];
852temps=temps+400;
853tabtiming[nummoteur]=temps;}
854
855for(int  l=30;l<100; l++) {
856nummoteur=tabordre[l];
857temps=temps+200;
858tabtiming[nummoteur]=temps;}
859
860
861
862
863tempsdepart=millis();//  on prend le temps du départ
864
865while(a<1){
866  for (int i=0;i<100;i++){// on  boucle pour chaque goutte, mais au moment de la première goutte on change au bout  d'un moment certain parametre
867delayMicroseconds(1);// ça ne fonctionne pas sinon
868
869if(millis()-tempsdepart>tabtiming[i]){   
870
871tempsdutrajet=2;//tempsdutrajet en seconde
872calculvitesseetacc (tempsdutrajet,targetposinf[i]-targetpossup[i],  0.15);// calcul de la vitesse et de l'accelerationn en fonction du temps du rajet  de la longueure du trajet et du % d'acceleration 
873
874 moteurplus(i,setmaxspeed,v);//
875  moteurplus(i,setmaxacceleration,ac);
876 moteurplus(i,setmaxdecceleration,ac); 
877delayMicroseconds(10);
878  
879//if(tabmontil[i]==true){
880//  moteurplus(i,settargetposition,targetpossup[i]);
881//  tabmontil[i]=false;
882//  }
883//
884// else{
885  moteurplus(i,settargetposition,targetposinf[i]);
886  // tabmontil[i]=true;
887 // }
888  
889//  tabtiming[i]=tabtiming[i]+tempsdutrajet*1000;//  on repart
890
891if(i==tabordre[99]){a=1;}// c'est fini au monent ou la dernière  goutte est tombée
892}
893
894}
895
896}
897
898delay(3000);
899//remonteretmettreazero(tempspourremonter);
900
901
902
903}
904
905
906
907
908
909
910
911
912
913//***************************  commande avec plus que 127 moteurs*******************************
914// dans le  protocle pour communiquer avec les tic, le premier byte est toujurs complets puis  ceux qui viennent après le bi 7 est toujours à 0
915// la communciation avec les  tics , si on veut utiliser plus que 127 moteurs , il faut d'abord envoyer le premier  byte=0xAA, puis tous les autres seront avec le bit 7 à 0
916// donc 2 bytes pour  le numéro du device (bi7 à0), 1 byte pour le numéro de la commande (avec le bit7=0),  puis 5 bytes pour les positions ou vitesse ou acceleration
917
918void moteurplus(int  deviceNumber,uint8_t command,int32_t target)
919{
920//deviceNumber = 1000; //Can  be anywhere from 0 to 16383
921
922      
923uint8_t deviceNumberLower = deviceNumber  & 0x7F;
924uint8_t deviceNumberUpper = (deviceNumber >> 7) & 0x7F;
925
926//int32_t  target = 200;
927
928
929
930uint8_t msb = ((target >> 7) & 1) | ((target >> 14)  & 2) | ((target >> 21) & 4) | ((target >> 28) & 8);
931uint8_t data1 = (target >>  0) & 0x7F;
932uint8_t data2 = (target >> 8) & 0x7F;
933uint8_t data3 = (target >>  16) & 0x7F;
934uint8_t data4 = (target >> 24) & 0x7F;
935
936//start byte
937Serial1.write(0xAA);
938
939//14-bit  device number
940Serial1.write(deviceNumberLower); 
941Serial1.write(deviceNumberUpper);
942
943//0xE0  command byte with MSB cleared // set target position = 0xE0
944uint8_t commandmsbclear  = command & 0x7F;
945Serial1.write(commandmsbclear); 
946
947//data bytes for target  position
948Serial1.write(msb); 
949Serial1.write(data1); 
950Serial1.write(data2);
951Serial1.write(data3);
952Serial1.write(data4);
953
954
955
956
957
958}
959//  **********exit safe start**********
960void exitsafedebut(int deviceNumber){
961uint8_t  deviceNumberLower = deviceNumber & 0x7F;
962uint8_t deviceNumberUpper = (deviceNumber  >> 7) & 0x7F;
963
964//start byte
965Serial1.write(0xAA);
966//14-bit device number
967Serial1.write(deviceNumberLower);  
968Serial1.write(deviceNumberUpper);
969
970// command
971Serial1.write(0x03);
972}
973
974//  **********set step mode**********//0 =full;1=1/2, 2=1/4,  3=1/8
975void setstepmode(int  deviceNumber, int stepmode){
976uint8_t deviceNumberLower = deviceNumber & 0x7F;
977uint8_t  deviceNumberUpper = (deviceNumber >> 7) & 0x7F;
978
979//start byte
980Serial1.write(0xAA);
981//14-bit  device number
982Serial1.write(deviceNumberLower); 
983Serial1.write(deviceNumberUpper);
984
985//  command
986Serial1.write(0x94);
987
988// data
989
990Serial1.write(stepmode);
991
992}
993
994//**********************************************************************
995void  delaiavecbluetooth(unsigned long delai)
996{
997unsigned long tempsdepart;
998tempsdepart=millis();
999while(millis()<tempsdepart+delai)
1000{
1001
1002controlbluetooth()  ; // ceci fonctionne si on veut recevoir dans une variable ce ui arrive du natel  format : texte=12#
1003}
1004}
1005
1006
1007
1008
1009//**********************************************************************
1010//  envoi d'une chaine du natel vers le bluetooth de l'arduino
1011
1012// pour le module  HC-08BLE bluetooth BT05
1013// VCC sur 5volt de l'arduino
1014// GND sur GND de l'arduino
1015//  RX du module blutooth va sur le TX2 pin 16 de l'arduino, mais il passe par un pont  de ressitance de220 ohms pour transformer le 5v de l'arduino en 3v
1016// TX du module  bluetooth var sur le RX2  pin 17 de l'aeduino
1017// ne pas oublier d'activer le  bluetoth sur le telephone
1018
1019//le natel envoie une chaine de caractère terminée  par #, puis lorsque le # est atteint, il rajoute un '\\0' pour terminer la string
1020//  puis il extrait le premier bout de chaine séparé de l'aure par un =
1021// exemple:  "a=101#" s=1# etc  IMPORTANT le bluetoth s'appelle ALAIN si il n'apparait pas  sur le natel desactiver le bluetooth et le réactiver
1022
1023void controlbluetooth(){
1024  
1025  byte ndx = 0;
1026 char rc;
1027char messageFromPC[numChars] = {0};
1028 
1029  while (Serial2.available() > 0 && newData == false)  {
1030
1031        rc = Serial2.read();
1032        if (rc != '#') {
1033        receivedChars[ndx] = rc;
1034        ndx=ndx+1;
1035   delay(100);  // si on ne met pas cette attente le while voit qu'il n'y a plus  de  Serial2.available() et sort du while   
1036                
1037                  if  (ndx >= numChars) {
1038                    ndx = numChars - 1;
1039                }}
1040else  {
1041 
1042                receivedChars[ndx] = '\\0'; // terminate the string
1043       ndx = 0;
1044       
1045 newData=true;
1046
1047 
1048 }
1049}
1050
1051
1052// reçoit  "numero=101" et séparation de receivedChars en 2 chaines distinctes messageFromPC  et  integer1FromPC: numéro     puis 101
1053
1054if (newData == true) {
1055 
1056char  * chaine; // this is used by strtok() dont on ne sait pas à priori la longieur de  chaine donc on met un * qui fait que chaine devient un pointeur vers le début de  chaine
1057 strcpy(tempChars, receivedChars);// copie la string receivedChars dans  tempChars
1058 chaine = strtok(tempChars,"=");   //    // obtient la première partie  de la string
1059 strcpy(messageFromPC, chaine); // copy it to messageFromPC
1060  chaine = strtok(NULL, "");// le Null veut dire qu'on prend toujours tempschars  ez qu'on continue a chercher des delimitateurs ici ""
1061    integer0FromPC =  atof(chaine);// trabsforne une chaine de caractere en float
1062
1063
1064
1065messagerecu=String(messageFromPC);//  transforme la chaine de caratcetre reçu en string
1066Serial.println(messageFromPC);
1067Serial.println(  integer0FromPC);
1068
1069if(messagerecu=="t"){
1070tempsdutrajet=integer0FromPC;
1071tprecedent=0;  
1072t=0;
1073laps1=0;
1074laps2=0; 
1075incr=0;}
1076
1077if(messagerecu=="a"){
1078alphaincr=integer0FromPC;
1079tprecedent=0;  
1080t=0;
1081laps1=0;
1082laps2=0; 
1083incr=0;}
1084
1085if(messagerecu=="s"){
1086remonteretmettreazero(23);
1087}
1088
1089
1090
1091//Serial.println(  tempsdutrajet);
1092//Serial.println(  alphaincr);
1093
1094}
1095newData=false;
1096
1097}
1098
1099
1100//***********************************************************************************
1101//***********************************************************************************
1102//****  Chenille  ******************
1103//***********************************************************************************
1104
1105void  chenille(){
1106
1107int longueurchenille=2;
1108int xchenille[longueurchenille];
1109int  ychenille[longueurchenille];
1110int xincrement=1;
1111int yincrement=1;
1112int x=0;
1113int  y=0;
1114float tempstrajetavant=0.5;
1115
1116for(int k=0;k<longueurchenille;k++){
1117xchenille[k]=x-k;
1118ychenille[k]=y-k;}
1119float  target=5000;
1120  
1121
1122for(int i=0;i<100;i++){
1123targetprochain[i]=target;
1124targetpreced[i]=target;
1125}
1126
1127positionmoteur(target);
1128delay(12000);
1129
1130xincrement=1;
1131yincrement=0;
1132for(int  ii=0;ii<1000;ii++){
1133
1134if(ii%5==0){
1135xincrement=(random(0,199)%3)-1;
1136yincrement=(random(0,300)%3)-1;
1137}
1138
1139
1140if(((xchenille[0]+xincrement)!=xchenille[0])|((ychenille[0]+yincrement)!=ychenille[0])){
1141if(((xchenille[0]+xincrement)!=xchenille[1])|((ychenille[0]+yincrement)!=ychenille[1])){
1142
1143
1144
1145
1146targetprochain[xchenille[0]]=target-1000;
1147
1148unmoteuracetteposition(xchenille[0],  ychenille[0], tempstrajetavant,targetprochain[xchenille[0]], target);// on monte  l'avant     unmoteuracetteposition( int x, int y, float tempstrajet, float newtarget,  float targetprecedent)
1149
1150unmoteuracetteposition(xchenille[longueurchenille-1],  ychenille[longueurchenille-1], tempstrajetavant+0.5,target,targetpreced[xchenille[longueurchenille-1]]);//  on descend l'arrière
1151
1152targetpreced[xchenille[0]]=targetprochain[xchenille[0]];
1153
1154
1155for(int  i=longueurchenille-1;i>0;i--){// décalage de tous les élements de la chenille
1156xchenille[i]=xchenille[i-1];
1157ychenille[i]=ychenille[i-1];
1158targetpreced[i]=targetpreced[i-1];
1159}
1160
1161xchenille[0]=xchenille[0]+xincrement;
1162ychenille[0]=ychenille[0]+yincrement;
1163
1164//if(xchenille[0]<0){xchenille[0]=9;}
1165//if(xchenille[0]>9){xchenille[0]=0;}
1166//if(ychenille[0]<0){ychenille[0]=9;}
1167//if(ychenille[0]>9){ychenille[0]=0;}
1168
1169if(xchenille[0]<0){xchenille[0]=0;}
1170if(xchenille[0]>9){xchenille[0]=9;}
1171if(ychenille[0]<0){ychenille[0]=0;}
1172if(ychenille[0]>9){ychenille[0]=9;}
1173
1174//if(xchenille[0]>8){xincrement=0;yincrement=1;}
1175//if(xchenille[0]>9){xchenille[0]=0;}
1176//if(ychenille[0]<0){ychenille[0]=9;}
1177//if(ychenille[0]>9){ychenille[0]=0;}
1178
1179alpha=alpha+alphaincr;
1180delay(tempstrajetavant*1000/longueurchenille);
1181
1182}}
1183
1184}
1185positionmoteur(target);
1186delay(12000);
1187
1188}
1189
1190
1191
1192
1193
1194
1195
1196//*******************************  calcul de la vitesse et de l'acceleration en fonction du temps du trajet de la longieure  du trajet et du % d'acceleration
1197
1198
1199void calculvitesseetacc (float tempstrajet,  float longueuretrajet, float fraxacc)
1200{
1201  frax=0.15;// c'est à dire 20% dutrajet  en acceleration; 60% en vitesse constante et 20% en deceleration, maximum c'est  0.5
1202// en fait pour de court trajet genre sinus (alpha =alpha+01, il faut mettre  frax au minimum=0.001
1203//ça marche bien avec 0.2 et un délai plus court entre  chaque salve de commande
1204// a= Path/(t au carré *frax*(1-frax))
1205// a*t*frax=v
1206float  tinter=tempstrajet*tempstrajet;
1207tinter=tinter*fraxacc; 
1208tinter=tinter*(1-fraxacc);
1209float  tinter2=tempstrajet*fraxacc;
1210
1211ac=longueuretrajet/tinter;
1212v=ac*tinter2;
1213ac=ac*100;
1214v=v*10000;
1215
1216}
1217
1218//***********************************  1moteuracette position en un temps donné en fonction de la nouvelle positioon et  de l'ancienne
1219
1220void unmoteuracetteposition( int x, int y, float tempstrajet,  float newtarget, float targetprecedent)
1221{
1222
1223 if((x>-1)&&(x<10)){
1224  if  ((y>-1)&&(y<10)){
1225
1226
1227calculvitesseetacc(tempstrajet,abs(newtarget-targetprecedent),0.15);
1228  int nummoteur=x*10+y;
1229 moteurplus(nummoteur,setmaxspeed,v);//
1230 moteurplus(nummoteur,setmaxacceleration,ac);
1231  moteurplus(nummoteur,setmaxdecceleration,ac); 
1232delayMicroseconds(10);
1233 moteurplus(nummoteur,settargetposition,newtarget);
1234}
1235  }
1236 }
1237// ********************************************* assignation départ des  timing gouttes
1238void assignationdepart(int x, int y, unsigned long temps, float  targetinf, float targetsup, bool monte)
1239{
1240    if((x>=0)&&(x<10)){
1241      if((y>=0)&&(y<10)){
1242    nummoteur=x*10+y;
1243  tabtiming[nummoteur]=temps;
1244  tabmontil[nummoteur]=monte;//  les gouttes vont monter
1245  targetpossup[nummoteur]=targetsup;
1246  targetposinf[nummoteur]=targetinf;  
1247    }}
1248}
1249// ***********************************************************************************************
1250void  scenario1departgoutte()
1251
1252{// assignation de départ des gouttes
1253 unsigned  long temps=0;//  en ms la première salve de gouttes partent au bout de 0 secondes
1254  unsigned long tempsentregoutte=200; //en ms , pas moins de 100ms
1255 nbrdefois=7;
1256  dernieregoutte=55;
1257 tempspourremonter=8;
1258 longueuronde=16;
1259  
1260 for (int  y=0;y<10;y++){
1261    for (int x=0;x<2;x++){assignationdepart(x,y,temps,4000,1000,false)  ;}  //(int x, int y, unsigned long temps, float targetinf, float targetsup, bool  monte)
1262    temps=temps+tempsentregoutte;}// la prochaine salve partira apres  tant de ms
1263
1264 for (int x=2;x<10;x++){
1265    for (int y=8;y<10;y++){assignationdepart(x,y,temps,4000,1000,false)  ;}  //(int x, int y, unsigned long temps, float targetinf, float targetsup, bool  monte)
1266    temps=temps+tempsentregoutte;}// la prochaine salve partira apres  tant de ms
1267
1268 for (int y=7;y>-1;y--){
1269    for (int x=8;x<10;x++){assignationdepart(x,y,temps,4000,1000,false)  ;}  //(int x, int y, unsigned long temps, float targetinf, float targetsup, bool  monte)
1270    temps=temps+tempsentregoutte;}// la prochaine salve partira apres  tant de ms
1271
1272 for (int x=7;x>1;x--){
1273    for (int y=0;y<2;y++){assignationdepart(x,y,temps,4000,1000,false)  ;}  //(int x, int y, unsigned long temps, float targetinf, float targetsup, bool  monte)
1274    temps=temps+tempsentregoutte;}// la prochaine salve partira apres  tant de ms
1275
1276
1277 temps=temps+tempsentregoutte;
1278  temps=temps+tempsentregoutte;
1279  temps=temps+tempsentregoutte;// un délai plus long avant que celles du milieu  descencent
1280 for (int y=3;y<7;y++){
1281    for (int x=3;x<7;x++){assignationdepart(x,y,temps,6000,500,false)  ;}  //(int x, int y, unsigned long temps, float targetinf, float targetsup, bool  monte)
1282  }// la prochaine salve partira apres tant de ms
1283    
1284  // fin  d'assignation de départ des gouttes
1285}
1286
1287// ***********************************************************************************************
1288void  scenario2departgoutte()
1289
1290{// assignation de départ des gouttes
1291 unsigned  long temps=0;//  en ms la première salve de gouttes partent au bout de 0 secondes
1292  unsigned long tempsentregoutte=800; //en ms , pas moins de 100ms
1293 nbrdefois=5;
1294  dernieregoutte=55;
1295 tempspourremonter=11;
1296  longueuronde=20;
1297  
1298 for  (int y=0;y<10;y++){
1299    assignationdepart(0,y,temps,4000,1000,false) ;//(int  x, int y, unsigned long temps, float targetinf, float targetsup, bool monte)
1300     assignationdepart(9,y,temps,4000,1000,false) ;}  
1301 for (int x=1;x<9;x++){
1302    assignationdepart(x,0,temps,4000,1000,false) ;//(int x, int y, unsigned long  temps, float targetinf, float targetsup, bool monte)
1303     assignationdepart(x,9,temps,4000,1000,false)  ;}
1304 temps=temps+tempsentregoutte;// la prochaine salve partira apres tant de  ms
1305
1306 for (int y=1;y<9;y++){
1307    assignationdepart(1,y,temps,5000,1000,false)  ;//(int x, int y, unsigned long temps, float targetinf, float targetsup, bool monte)
1308     assignationdepart(8,y,temps,5000,1000,false) ;}  
1309 for (int x=2;x<8;x++){
1310    assignationdepart(x,1,temps,5000,1000,false) ;//(int x, int y, unsigned long  temps, float targetinf, float targetsup, bool monte)
1311     assignationdepart(x,8,temps,5000,1000,false)  ;}
1312 temps=temps+tempsentregoutte;// la prochaine salve partira apres tant de  ms
1313
1314  for (int y=2;y<8;y++){
1315    assignationdepart(2,y,temps,6000,1000,false)  ;//(int x, int y, unsigned long temps, float targetinf, float targetsup, bool monte)
1316     assignationdepart(7,y,temps,6000,1000,false) ;}  
1317 for (int x=3;x<7;x++){
1318    assignationdepart(x,2,temps,6000,1000,false) ;//(int x, int y, unsigned long  temps, float targetinf, float targetsup, bool monte)
1319     assignationdepart(x,7,temps,6000,1000,false)  ;}
1320 temps=temps+tempsentregoutte;// la prochaine salve partira apres tant de  ms
1321
1322  for (int y=3;y<7;y++){
1323    assignationdepart(3,y,temps,7000,1000,false)  ;//(int x, int y, unsigned long temps, float targetinf, float targetsup, bool monte)
1324     assignationdepart(6,y,temps,7000,1000,false) ;}  
1325 for (int x=4;x<6;x++){
1326    assignationdepart(x,3,temps,7000,1000,false) ;//(int x, int y, unsigned long  temps, float targetinf, float targetsup, bool monte)
1327     assignationdepart(x,6,temps,7000,1000,false)  ;}
1328 temps=temps+tempsentregoutte;// la prochaine salve partira apres tant de  ms
1329   
1330   for (int y=4;y<6;y++){
1331    assignationdepart(4,y,temps,7500,1000,false)  ;//(int x, int y, unsigned long temps, float targetinf, float targetsup, bool monte)
1332     assignationdepart(5,y,temps,7500,1000,false) ;}  
1333assignationdepart(5,4,temps,7500,1000,false)  ;
1334assignationdepart(5,5,temps,7500,1000,false) ;
1335 //temps=temps+tempsentregoutte;//  la prochaine salve partira apres tant de ms
1336    
1337}
1338
1339// ***********************************************************************************************
1340void  scenario3departgoutte()
1341
1342{// assignation de départ des gouttes
1343 unsigned  long temps=0;//  en ms la première salve de gouttes partent au bout de 0 secondes
1344  unsigned long tempsentregoutte=1000; //en ms , pas moins de 100ms
1345 
1346 nbrdefois=5;
1347  dernieregoutte=45;
1348 tempspourremonter=8;
1349 longueuronde=20;
1350 // drawCircle(int  x0, int y0, int r,  unsigned long temps, float targetinf, float targetsup, bool  monte)
1351
1352 drawCircle(5, 5, 4, temps, 4000, 1000, false);
1353temps=temps+tempsentregoutte;//  la prochaine salve partira apres tant de ms
1354 drawCircle(5, 5, 3, temps, 4500,  1000, false);
1355temps=temps+tempsentregoutte;// la prochaine salve partira apres  tant de ms
1356 drawCircle(5, 5, 2, temps, 5000, 1000, false);
1357temps=temps+tempsentregoutte;//  la prochaine salve partira apres tant de ms
1358 drawCircle(5, 5, 1, temps, 5500,  1000, false);
1359
1360
1361
1362
1363// drawCircle(0, 0, 4, temps, 4000, 1000, false);
1364//  drawCircle(9, 9, 4, temps, 4000, 1000, false);
1365//drawCircle(0, 9, 4, temps,  4000, 1000, false);
1366//  drawCircle(9, 0, 4, temps, 4000, 1000, false);
1367//temps=temps+tempsentregoutte;//  la prochaine salve partira apres tant de ms
1368//
1369// drawCircle(0, 0, 3, temps,  4000, 1000, false);
1370//  drawCircle(9, 9, 3, temps, 4000, 1000, false);
1371//drawCircle(0,  9, 3, temps, 4000, 1000, false);
1372//  drawCircle(9, 0, 3, temps, 4000, 1000, false);
1373//temps=temps+tempsentregoutte;//  la prochaine salve partira apres tant de ms
1374//
1375// drawCircle(0, 0, 2, temps,  4000, 1000, false);
1376//  drawCircle(9, 9, 2, temps, 4000, 1000, false);
1377//drawCircle(0,  9, 2, temps, 4000, 1000, false);
1378//  drawCircle(9, 0, 2, temps, 4000, 1000, false);
1379//temps=temps+tempsentregoutte;//  la prochaine salve partira apres tant de ms
1380
1381
1382
1383
1384    
1385  // fin  d'assignation de départ des gouttes
1386}
1387
1388// ***********************************************************************************************
1389void  scenario4departgoutte()
1390//
1391{// assignation de départ des gouttes
1392 unsigned  long temps=0;//  en ms la première salve de gouttes partent au bout de 0 secondes
1393  unsigned long tempsentregoutte=200; //en ms , pas moins de 100ms
1394 nbrdefois=11;
1395  dernieregoutte=0;
1396 tempspourremonter=12.5;
1397  longueuronde=20;
1398//writeLine(byte  x0, byte y0, byte x1, byte y1, unsigned long temps, float targetinf, float targetsup,  bool monte)
1399
1400writeLine (0,0,9,0,temps,4000,2000,false);
1401temps=temps+tempsentregoutte;//  la prochaine salve partira apres tant de ms
1402
1403writeLine(0,1,9,1,temps,4500,2000,false);
1404temps=temps+tempsentregoutte;//  la prochaine salve partira apres tant de ms
1405
1406writeLine(0,2,9,2,temps,5000,2000,false);
1407temps=temps+tempsentregoutte;//  la prochaine salve partira apres tant de ms
1408
1409writeLine(0,3,9,3,temps,5500,2000,false);
1410temps=temps+tempsentregoutte;//  la prochaine salve partira apres tant de ms
1411
1412writeLine(0,4,9,4,temps,6000,2000,false);
1413temps=temps+tempsentregoutte;//  la prochaine salve partira apres tant de ms
1414
1415writeLine(0,5,9,5,temps,6500,2000,false);
1416temps=temps+tempsentregoutte;//  la prochaine salve partira apres tant de ms
1417
1418writeLine(0,6,9,6,temps,7000,2000,false);
1419temps=temps+tempsentregoutte;//  la prochaine salve partira apres tant de ms
1420
1421writeLine(0,7,9,7,temps,7500,2000,false);
1422temps=temps+tempsentregoutte;//  la prochaine salve partira apres tant de ms
1423
1424writeLine(0,8,9,8,temps,8000,2000,false);
1425temps=temps+tempsentregoutte;//  la prochaine salve partira apres tant de ms
1426
1427writeLine(0,9,9,9,temps,8500,2000,false);
1428temps=temps+tempsentregoutte;//  la prochaine salve partira apres tant de ms
1429
1430
1431
1432}
1433
1434
1435
1436
1437
1438
1439//  cercle
1440//*************************************************************************************
1441
1442//  assignation des temps de départ en cercle
1443
1444void drawCircle(int x0, int y0,  int r,  unsigned long temps, float targetinf, float targetsup, bool monte) {
1445  if(r>0){
1446    int f = 1 - r;
1447    int ddF_x = 1;
1448    int ddF_y = -2 * r;
1449    int x = 0;
1450    int y = r;
1451
1452
1453assignationdepart(x0, y0 + r,temps,targetinf,targetsup,monte);
1454assignationdepart(x0,  y0 - r,temps,targetinf,targetsup,monte);
1455assignationdepart(x0+r, y0,temps,targetinf,targetsup,monte);
1456assignationdepart(x0-r,  y0,temps,targetinf,targetsup,monte);
1457
1458
1459
1460    while (x<y) {
1461        if  (f >= 0) {
1462            y--;
1463            ddF_y += 2;
1464            f += ddF_y;
1465        }
1466        x++;
1467        ddF_x += 2;
1468        f += ddF_x;
1469assignationdepart(x0,  y0 + r,temps,targetinf,targetsup,monte);
1470        
1471assignationdepart(x0+x,  y0 + y,temps,targetinf,targetsup,monte);
1472assignationdepart(x0-x, y0 + y,temps,targetinf,targetsup,monte);
1473assignationdepart(x0+x,  y0 - y,temps,targetinf,targetsup,monte);
1474assignationdepart(x0-x, y0 - y,temps,targetinf,targetsup,monte);
1475assignationdepart(x0+y,  y0 + x,temps,targetinf,targetsup,monte);
1476assignationdepart(x0-y, y0 + x,temps,targetinf,targetsup,monte);
1477assignationdepart(x0+y,  y0 - x,temps,targetinf,targetsup,monte);
1478assignationdepart(x0-y, y0 - x,temps,targetinf,targetsup,monte);
1479
1480    }
1481  }
1482}
1483
1484
1485//**************************************************************************/
1486/*!
1487   @brief    Write a line.  Bresenham's algorithm - thx wikpedia
1488    @param    x0  Start point x coordinate
1489    @param    y0  Start point y coordinate
1490    @param    x1  End point x coordinate
1491    @param    y1  End point y coordinate
1492    @param    color 16-bit 5-6-5 Color to draw with
1493*/
1494//**************************************************************************
1495
1496void  writeLine(int x0, int y0, int x1, int y1, unsigned long temps, float targetinf,  float targetsup, bool monte) {
1497
1498
1499if((x0==x1)or(y0==y1)){
1500
1501if(y0==y1){//  on dessine une ligne horizontale
1502byte longeur=abs(x1-x0)+1;
1503for(byte x=0;x<longeur;x++){
1504   assignationdepart(x+x0, y0,temps,targetinf,targetsup,monte);  }}
1505
1506
1507else{//  on dessine une ligne verticale
1508    byte longueur=abs(y1-y0)+1;
1509for(byte y=0;  y<longueur; y++){
1510 
1511  assignationdepart(x0, y+y0,temps,targetinf,targetsup,monte);}
1512
1513}
1514
1515  
1516}
1517else{// c'est ni une horizontale ni une verticale
1518    int steep = abs(y1  - y0) > abs(x1 - x0);
1519  
1520    if (steep) {
1521        swap(x0, y0);
1522        swap(x1,  y1);
1523    }
1524
1525    if (x0 > x1) {
1526        swap(x0, x1);
1527        swap(y0,  y1);
1528    }
1529
1530    int dx, dy;
1531    dx = x1 - x0;
1532    dy = abs(y1 - y0);
1533
1534    int err = dx / 2;
1535    int ystep;
1536
1537    if (y0 < y1) {
1538        ystep  = 1;
1539    } else {
1540        ystep = -1;
1541    }
1542
1543    for (; x0<=x1; x0++)  {
1544        if (steep) {
1545     
1546         assignationdepart(y0, x0,temps,targetinf,targetsup,monte);
1547
1548    
1549        } else {
1550            
1551          assignationdepart(x0, y0,temps,targetinf,targetsup,monte);
1552        
1553        }
1554        err -= dy;
1555        if (err < 0) {
1556            y0  += ystep;
1557            err += dx;
1558        }
1559    }
1560}
1561}

1
2//#include <Tic.h>// pas besoin de cette bibliotheque , car je gère
3  l'écriture des bytes moi-même
4
5#ifdef SERIAL_PORT_HARDWARE_OPEN
6#define
7  ticSerial SERIAL_PORT_HARDWARE_OPEN
8#else
9#include <SoftwareSerial.h>
10SoftwareSerial
11  Serial1(18, 19); //pour arduino 2560 18 tx sur arduino (transmet)  pour rx (reçois)sur
12  le tic
13#endif
14
15
16#define swap(a,b){int t=a;a=b;b=t;}//utilisé pour dessiner
17  une ligne
18//TicSerial tic1000(ticSerial, 1000); pas besoin de créer un objet
19  de ce type car je n'utilise plus la bibliotheque tic.h
20
21// numéro des commandes
22  utilisées
23uint8_t haltandsetposition=0xEC;
24uint8_t setmaxspeed=0xE6;
25uint8_t
26  settargetposition=0xE0;
27uint8_t setmaxacceleration=0xEA;
28uint8_t setmaxdecceleration=0xE9;
29//uint8_t
30  setstepmode=0x94;//0 =full;1=1/2, 2=1/4,  3=1/8
31//*******************
32float
33  target[100];
34float targetpreced[100];
35float targetprochain[100];
36float
37  grandeurtrajet[100];
38unsigned long tabtiming[100];
39bool tabmontil[100];
40float
41  targetpossup[100];
42float targetposinf[100];
43
44float trajetleplusgrand=0;
45float
46  vitesselaplusgrande=0;
47float frax=0.3; // c'est la fraction du temps pour faire
48  le trajet pendant laquelle ça acceélere ou decellere
49float ac=10000;// acceleration
50int
51  nummoteur=0;
52float vitessemax=10000000;
53float d=0;
54float d2=0;
55float
56  v=0;// vitesse
57float tempsdutrajet=1;// est aussi defini par le bluetooth en
58  envoyant depuis le natel t=2.5#
59float alpha=0;
60float alphaincr=0.3;// est
61  aussi defini par le bluetooth en envoyant depuis le natel a=0.4#
62float beta=0;
63float
64  betaincr=0.1;
65float gamma=0;
66float gammaincr=0.1;
67bool count=true;
68bool
69  count2=true;
70unsigned long t;
71unsigned long tprecedent;
72int laps1;
73int
74  laps2;
75int incr=0;
76
77float tinter=0;
78float tinter2=0;
79
80int endroit=4000;
81float
82  parametre=0.1;
83
84int nbrdefois=0;
85int dernieregoutte=0;
86int tempspourremonter=10;
87unsigned
88  long longueuronde=20;
89//*******************
90// pour le bluetooth
91String
92  msg="";
93
94const byte numChars = 32;
95char receivedChars[numChars];
96char
97  tempChars[numChars];        // temporary array for use when parsing
98char messageFromPC[numChars]
99  = {0};// variables to hold the parsed data
100String messagerecu="";
101float
102  integer0FromPC = 0;
103
104boolean newData = false;
105
106
107
108
109
110
111//
112  dans l'app pololu mettre max accelartion à 1000000(1 milion, c'est super réactif);
113  mais c'est tres saccadé préféré 200000
114// idéalement il faudrait calculé le temps
115  exact avec l'acceleration 
116
117// et votesse max à 100000000 ( 100 milion)
118void
119  setup()
120{
121  Serial.begin(115200);// pour le moniteur
122  Serial1.begin(115385);//
123  serial1 permet d'écrire les bytes dans les moteurs
124  Serial2.begin(9600); //pour
125  le bluetooth pin 16 17
126
127
128  // Give the Tic some time to start up.
129  delay(20);
130
131
132  // Set the Tic's current position to 0, so that when we command
133  // it to
134  move later, it will move a predictable amount.
135  //  // Tells the Tic that it
136  is OK to start driving the motor.  The
137//  // Tic's safe-start feature helps
138  avoid unexpected, accidental
139//  // movement of the motor: if an error happens,
140  the Tic will not
141//  // drive the motor again until it receives the Exit Safe
142  Start
143//  // command.  The safe-start feature can be disbled in the Tic
144
145
146
147  for (int i=0;i<100;i++){
148  moteurplus(i,haltandsetposition,0);//haltandsetposition
149  avec plus de 127 moteurs
150 exitsafedebut(i);//exitsafestart avec plus de 127 moteurs,
151  si il y a une coupure de courant par exemple le moteur ne redemarre pas sauf si
152  on utilie cette commande ou si dans
153 // dans le controlleur Tic on mette Disable
154  safe start
155   }
156
157
158 }
159
160
161 
162
163
164
165
166
167
168void loop()
169{
170
171if
172  (count==true){
173  count=false;
174
175remonteretmettreazero(20);// attendre 23
176  secondes
177}
178
179
180
181courbe();
182vaguepastoute();
183
184dessincourbe(15,6,6,2999);//
185  numéro de la courbe et temps du trajet en seconde et temps d'arret et parametre
186    // cercle 
187dessincourbe(15,6,6,-2999);// numéro de la courbe et temps du
188  trajet en seconde et temps d'arret et parametre    //cercle inversé
189dessincourbe(15,6,6,2999);//
190  numéro de la courbe et temps du trajet en seconde et temps d'arret et parametre
191    //cercle
192dessincourbe(15,6,6,-2999);// numéro de la courbe et temps du trajet
193  en seconde et temps d'arret et parametre    //cercle inversé
194dessincourbe(14,6,6,0);//
195  on remonte à zero tous en même tempsnuméro de la courbe et temps du trajet et temps
196  d'arret et parametre  // remonte tous
197remonteretmettreazero(2); // mettre à zero
198
199chute();
200vague();
201sinus();
202
203
204remonteretmettreazero(23);
205//chenille();
206
207//testmoteur(5000,0,0);
208//testmoteur(5000,0,1);
209
210
211
212controlbluetooth()
213  ; // ceci fonctionne si on veut recevoir dans une variable ce ui arrive du natel
214  format : texte=12#
215
216
217
218}
219
220
221
222/////////////*******************************************************************************
223
224void
225  testmoteur(int targetpos, int x,int y)
226
227{
228
229  for (int x=0;x<1;x++){
230
231    for (int y=0;y<10;y++){
232  nummoteur=x*10+y;
233   moteurplus(nummoteur,setmaxspeed,90000000);//
234
235    moteurplus(nummoteur,setmaxacceleration,1000000);
236 moteurplus(nummoteur,setmaxdecceleration,100000);
237  
238  moteurplus(nummoteur,settargetposition,targetpos);
239    }}
240delay(targetpos);
241
242  
243  for (int x=1;x<2;x++){
244    for (int y=0;y<10;y++){
245  nummoteur=x*10+y;
246
247   moteurplus(nummoteur,setmaxspeed,90000000);//
248    moteurplus(nummoteur,setmaxacceleration,1000000);
249
250  moteurplus(nummoteur,setmaxdecceleration,100000); 
251  moteurplus(nummoteur,settargetposition,targetpos);
252
253    }}
254delay(targetpos);
255
256for (int x=0;x<1;x++){
257    for (int y=0;y<10;y++){
258
259  nummoteur=x*10+y;
260 moteurplus(nummoteur,settargetposition,0);
261    }}
262delay(targetpos);
263
264
265  for (int x=1;x<2;x++){
266    for (int y=0;y<10;y++){
267  nummoteur=x*10+y;
268
269  moteurplus(nummoteur,settargetposition,0);
270    }}
271delay(targetpos);
272
273}
274/////////////*******************************************************************************
275
276void
277  positionmoteur(int targetpos)
278{
279// 1000 =15 cm en 1/4 de step ou 30 cm en
280  1/2 step
281//4000=60cm
282//8000=120cm
283if(targetpos>8000){targetpos=8000;}
284
285
286  for (int x=0;x<10;x++){
287    for (int y=0;y<10;y++){
288  nummoteur=x*10+y;
289
290   moteurplus(nummoteur,setmaxspeed,10000000);//
291    moteurplus(nummoteur,setmaxacceleration,100000);
292
293  moteurplus(nummoteur,setmaxdecceleration,10000); 
294 delay(1);
295  moteurplus(nummoteur,settargetposition,targetpos);
296
297}}
298
299
300
301}
302
303/////////////*******************************************************************************
304
305
306void
307  remonteretmettreazero(int delai)//delai en seconde
308{
309
310 for (int i=0;i<100;i++){
311
312  moteurplus(i,setmaxspeed,8000000);//9000000 
313 moteurplus(i,setmaxacceleration,100000);
314
315  moteurplus(i,setmaxdecceleration,100000); 
316 moteurplus(i,settargetposition,-23000);
317
318   }
319   
320//delaiavecbluetooth(23000);
321delay(delai*1000);
322for (int i=0;i<100;i++){
323
324  moteurplus(i,haltandsetposition,0);
325  exitsafedebut(i);
326  setstepmode(i,2);////0
327  =full;1=1/2, 2=1/4,  3=1/8
328  targetpreced[i]=0;
329
330}
331
332}
333/////////////*******************************************************************************
334
335void
336  courbe()
337{
338
339//
340dessincourbe(1,4.3,4.2,0);// numéro de la courbe et temps
341  du trajet en seconde et temps d'arret et parametre    // x2-y2
342dessincourbe(2,4,3.8,0);//
343  numéro de la courbe et temps du trajet et temps d'arret et parametre              //-(x2-y2)
344
345dessincourbe(5,5,4.9,0);//numéro
346  de la courbe et temps du trajet et temps d'arret et parametre           // sin(x/3)*sin(y/3)
347dessincourbe(6,5,4.9,0);//numéro
348  de la courbe et temps du trajet et temps d'arret et parametre            // // sin(x/3)*cos(y/3)
349dessincourbe(7,5,4.9,0);//numéro
350  de la courbe et temps du trajet et temps d'arret et parametre           // cos(x/3)*cos(y/3)
351
352dessincourbe(10,2.5,2.4,0);//
353  numéro de la courbe et temps du trajet et temps d'arret et parametre         //
354  x*y // vol oiseau
355dessincourbe(11,2.5,2.4,0);// numéro de la courbe et temps
356  du trajet et temps d'arret et parametre        //-(x*y)
357dessincourbe(10,2.5,2.4,0);//
358  numéro de la courbe et temps du trajet et temps d'arret et parametre         //
359  x*y
360dessincourbe(11,2.5,2.4,0);// numéro de la courbe et temps du trajet et temps
361  d'arret et parametre        //-(x*y)
362dessincourbe(12,3,2.8,0);// numéro de la
363  courbe et temps du trajet et temps d'arret et parametre         // -(x2+y2-2xy)
364dessincourbe(13,3,2.8,0);//
365  numéro de la courbe et temps du trajet et temps d'arret et parametre        //x2+y2-2xy
366dessincourbe(12,3,2.8,0);//
367  numéro de la courbe et temps du trajet et temps d'arret et parametre         //
368  -(x2+y2-2xy)
369dessincourbe(13,3,2.8,0);// numéro de la courbe et temps du trajet
370  et temps d'arret et parametre        //x2+y2-2xy// fin vol oiseau
371
372dessincourbe(3,5,4,0);//
373  numéro de la courbe et temps du trajet et temps d'arret et parametre            //
374  x2+y2//  bond et rebond
375dessincourbe(4,3,2.8,0);// numéro de la courbe et temps
376  du trajet et temps d'arret et parametre          // -(x2+y2)
377dessincourbe(3,3,2.8,0);//
378  numéro de la courbe et temps du trajet et temps d'arret et parametre         //
379  x2+y2
380dessincourbe(4,3,2.8,0);// numéro de la courbe et temps du trajet et temps
381  d'arret et parametre          // -(x2+y2)
382dessincourbe(3,3,3,0);// numéro de
383  la courbe et temps du trajet et temps d'arret et parametre         // x2+y2   /fin
384  de bon et rebond
385
386///////*************************** courbe 8
387  parametre=0.1;
388dessincourbe(8,5,5,parametre);
389  // numéro de la courbe et temps du trajet et temps d'arret et parametre // sin(x+y+parametre/3)
390for
391  (int i=0;i<50;i++){
392  parametre=parametre+0.5;
393dessincourbe(8,0.8,0.3,parametre);//numéro
394  de la courbe et temps du trajet et temps d'arret et parametre
395//ici de délai
396  d'attente est 0 car le temps de calcul est suffisant entre chaque intrscution donnée
397  toutes les 0.05 sec
398}
399
400///////***************************courbe 9
401
402
403  parametre=0.1;
404dessincourbe(9,5,8,parametre);// numéro de la courbe et temps
405  du trajet et temps d'arret et parametre // sin(x+parametre/)+sin(y+parametre/)+
406for
407  (int i=0;i<50;i++){
408  parametre=parametre+0.5;
409dessincourbe(9,0.8,0.3,parametre);//numéro
410  de la courbe et temps du trajet et temps d'arret et parametre
411
412//ici de délai
413  d'attente est 0 car le temps de calcul est suffisant entre chaque intrscution donnée
414  toutes les 0.01 sec
415//positionmoteur(5000);// 1000 =15 cm en 1/4 de step // 1000
416  =15 cm en 1/4 de step ou 30 cm en 1/2 step//4000=60cm//8000=120cm
417}
418
419///////***************************
420  courbe 14 on remonte tout
421dessincourbe(14,6,6,0);// on remonte à zero tous en
422  même tempsnuméro de la courbe et temps du trajet et temps d'arret et parametre 
423
424remonteretmettreazero(2);
425
426}//
427  fin de courbe
428
429
430/////////////*******************************************************************************
431void
432  dessincourbe(int numerodessin,  float temps, float tempsdelai,float parametre)
433{
434
435//calcul
436  de la prochaine position
437float kapa=0;//pour le dessin no 15
438  
439 for (int
440  x=0;x<10;x++){
441    for ( int y=0;y<10;y++){
442      nummoteur=x*10+y;
443
444if(numerodessin==1){
445
446    target[nummoteur]=3000-60*((x-5)*(x-5)-(y-5)*(y-5));// donc un trajet au max
447  de 1000=15cm; 2000=30cm
448}
449
450if(numerodessin==2){
451    target[nummoteur]=5000+60*((x-5)*(x-5)-(y-5)*(y-5));//
452  donc un trajet au max de 1000=15cm; 2000=30cm
453   }
454if(numerodessin==3){
455
456    target[nummoteur]=3500-70*((x-5)*(x-5)+(y-5)*(y-5));// donc un trajet au max
457  de 1000=15cm; 2000=30cm
458}
459
460if(numerodessin==4){
461    target[nummoteur]=4500+70*((x-5)*(x-5)+(y-5)*(y-5));//
462  donc un trajet au max de 1000=15cm; 2000=30cm
463   }
464   
465if(numerodessin==5){
466
467  float t=x-5;
468  float u=y-5;
469    target[nummoteur]=4000+2000*sin(t/3)*sin(u/3);//
470  donc un trajet au max de 1000=15cm; 2000=30cm
471   }
472   
473if(numerodessin==6){
474
475  float t=x-5;
476  float u=y-5;
477    target[nummoteur]=4000+2000*cos(t/3)*sin(u/3);//
478  donc un trajet au max de 1000=15cm; 2000=30cm
479   }
480   
481   if(numerodessin==7){
482
483  float t=x-5;
484  float u=y-5;
485    target[nummoteur]=4000+2000*cos(t/3)*cos(u/3);//
486  donc un trajet au max de 1000=15cm; 2000=30cm
487   }
488
489   if(numerodessin==8){
490
491  float t=x-5;
492  float u=y-5;
493    target[nummoteur]=4000+2000*sin((t+u+parametre)/3);//
494  donc un trajet au max de 1000=15cm; 2000=30cm
495   }
496
497   if(numerodessin==9){
498
499  float t=x-5;
500  float u=y-5;
501    target[nummoteur]=4000+1500*(sin((t+parametre)/2)+sin((u+parametre)/2));//
502  donc un trajet au max de 1000=15cm; 2000=30cm
503   }
504
505  if(numerodessin==10){
506
507  float t=x-5;
508  float u=y-5;
509    target[nummoteur]=4000+100*t*u;// donc un
510  trajet au max de 1000=15cm; 2000=30cm
511   }
512  if(numerodessin==11){
513  float
514  t=x-5;
515  float u=y-5;
516    target[nummoteur]=5000-100*t*u;// donc un trajet
517  au max de 1000=15cm; 2000=30cm
518   }
519  if(numerodessin==12){
520  float t=x-5;
521
522  float u=y-5;
523    target[nummoteur]=5000-40*(t*t+u*u-2*t*u);// donc un trajet
524  au max de 1000=15cm; 2000=30cm
525   }
526  if(numerodessin==13){
527  float t=x-5;
528
529  float u=y-5;
530    target[nummoteur]=4000+40*(t*t+u*u-2*t*u);// donc un trajet
531  au max de 1000=15cm; 2000=30cm
532   }
533
534 if(numerodessin==14){// on remonte
535  à 0 en même temps
536  target[nummoteur]=0;
537   }
538
539
540if(numerodessin==15){
541
542    target[nummoteur]=3000+parametre*sin(kapa);// donc un trajet au max de 1000=15cm;
543  2000=30cm// cercle
544    kapa=kapa+0.31415;
545   
546}
547
548
549
550   
551
552if(target[nummoteur]>8000){target[nummoteur]=8000;}//pour
553  ne pas aller trop bas
554
555grandeurtrajet[nummoteur]=abs(target[nummoteur]-targetpreced[nummoteur]);
556}}
557
558
559
560//calcul
561  de la vitesse pour y arriver tous en même temps
562for (int i=0;i<100;i++){
563calculvitesseetacc
564  (temps,grandeurtrajet[i], 0.15);
565
566moteurplus(i,setmaxspeed,v); 
567moteurplus(i,setmaxacceleration,ac);
568moteurplus(i,setmaxdecceleration,ac);
569  
570 delayMicroseconds(10);
571//nepas mettre ici  moteurplus(i,settargetposition,target[i]);
572  car le delay de 10ms fait qu'il y a un petit decalage dans les gouttes
573}
574
575
576for
577  (int i=0;i<100;i++){
578moteurplus(i,settargetposition,target[i]);
579targetpreced[i]=target[i];
580//delay(2);//
581  voir si vrament utile
582}
583
584delay(tempsdelai*1000);
585//delaiavecbluetooth(tempsdelai*1000);
586  ne fonctionne pas bien les gouttes desscendent trop bas
587
588
589
590
591}
592
593
594
595
596
597/////////////*******************************************************************************
598void
599  sinus()
600
601{
602//1 pulse/seconde= vitesse 10000
603// pour faire un tour il
604  faut 200 pulse en full, 800 en 1/4
605// 1 tour de poulie environ 12 cm donc 800
606  pulse , 24 cm =1600 pulse
607 unsigned long dureeprogrammedepart=0;
608 
609 tempsdutrajet=0.5;
610  // est donné par le bluetooth t=1.5#    pas descendre en dessous de 0.5 secondes
611  sinon accout pour de long trajet
612 alpha=0;
613 beta=0;
614 alphaincr=0.1;//des
615  increment plus grand que 0.3 font des décalages entre les moteurs
616 betaincr=0.1;
617
618  gammaincr=0.2;
619 frax=0.40;// c'est à dire 40% dutrajet en acceleration; 20% en
620  vitesse constante et40% en deceleration, maximum c'est 0.5
621// en fait pour de
622  court trajet genre sinus (alpha =alpha+01, il faut mettre frax au minimum=0.001
623//ça
624  marche bien avec 0.2 et un délai plus court entre chaque salve de commande
625//
626  a= Path/(t au carré *frax*(1-frax))
627// a*t*frax=v
628
629
630
631if (count2==true){
632
633  count2=false;
634//pour amener les gouttes au bon endroit avant de lancer sinus
635
636    for (int x=0;x<10;x++){
637    for (int y=0;y<10;y++){
638  nummoteur=x*10+y;
639
640   moteurplus(nummoteur,setmaxspeed,9000000);//
641    moteurplus(nummoteur,setmaxacceleration,100000);
642
643  moteurplus(nummoteur,setmaxdecceleration,100000); 
644  
645target[nummoteur]=4000+3000*sin(alpha+x*betaincr+y*0.2);//
646  donc un trajet au max de 1600+1550=3150/800=3.9X12cm=47cm
647
648if(target[nummoteur]>8000){target[nummoteur]=8000;}//pour
649  ne pas aller trop bas
650  
651  moteurplus(nummoteur,settargetposition,target[nummoteur]);
652targetpreced[nummoteur]=target[nummoteur];
653}}
654delay(10000);
655}
656
657
658dureeprogrammedepart=millis();
659
660while(millis()<dureeprogrammedepart+120000){//
661  durée de 3 minutes
662 Serial.println(millis()/1000);
663//calcul de la prochaine
664  position
665  for (int x=0;x<10;x++){
666    for (int y=0;y<10;y++){
667  nummoteur=x*10+y;
668
669  target[nummoteur]=4000+3000*sin(alpha+x*betaincr+y*0.2);// donc un trajet au max
670  de 1000=15cm; 2000=30cm
671  //Serial.print("x  :");Serial.print(x);Serial.print("
672  y  :");Serial.print(y);Serial.print("  target  :");Serial.println( target[nummoteur]);
673
674  if(target[nummoteur]>8000){target[nummoteur]=8000;}//pour ne pas aller trop bas
675
676
677  grandeurtrajet[nummoteur]=abs(target[nummoteur]-targetpreced[nummoteur]);
678
679  }
680}
681
682betaincr=betaincr+0.003;
683alpha=alpha+alphaincr;
684
685//calcul
686  de la vitesse pour y arriver tous en même temps
687for (int i=0;i<100;i++){
688
689calculvitesseetacc
690  (tempsdutrajet,grandeurtrajet[i], frax);// calcul de la vitesse et de l'accelerationn
691  en fonction du temps du rajet de la longueure du trajet et du % d'acceleration 
692
693moteurplus(i,setmaxspeed,v);
694  
695moteurplus(i,setmaxacceleration,ac);
696moteurplus(i,setmaxdecceleration,ac);
697  
698moteurplus(i,settargetposition,target[i]);
699targetpreced[i]=target[i];
700delayMicroseconds(1000);
701
702  
703}
704
705
706d2=(tempsdutrajet)*1000;
707incr=incr+1;
708t=millis();
709laps1=t-tprecedent;//
710  temps entre deux série d'envoi de commande (pour les 100 moteurs)sur les tics
711tprecedent=t;
712//
713  idélalement laps1 devrait être égale au tempsdutrajet , mais ça ne l'est pas car
714  le fait de mettre un délai=au tempsdutrajet s'ajoute encore le temps ppur executer
715  toutes les instrcution
716// donc il faut diminuer le délai
717if(incr==2){// avant
718  j'avais mis 3 mais ça fait buger les moteurs ????????
719  laps2=laps1;
720 laps2=laps2-(tempsdutrajet)*600;
721  // 700 au lieu de 1000 pour prndre le 70% de la durée du trajet
722 
723 if(laps2>d2){laps2=d2;}
724}
725delay(d2-laps2);
726
727}
728
729  remonteretmettreazero(20);
730}
731
732/////////////*******************************************************************************
733
734
735void
736  vague()
737{ 
738  
739float targetinf=4000;
740float targetsup=1000;
741
742 unsigned
743  long tempsdepart=0;// timing de l'arduino au début, il faut un unsigned long sinon
744  millis ne fonctionne pas correctement
745    
746 unsigned long temps=0;//  en ms
747  la première salve de gouttes partent au bout de 0 secondes
748 unsigned long tempsentregoutte=200;
749  //en ms , pas moins de 100ms 200 pose des problèmes
750 unsigned long longueuronde=15;
751  // demi longueure d'onde en goutte d'eau du prochain minimum
752// tempsdutrajet=longueuronde*tempsentregoutte/1000;//tempsdutrajet
753  en seconde
754int aa=1;
755int bb=0; //utiliser avec modulo
756int cc=1;
757int
758  dd=0;
759alpha=0;
760alphaincr=0.04;
761beta=0;
762betaincr=0.01;
763int nummoteur2=0;
764
765
766   // assignation de départ des gouttes
767  for (int x=0;x<10;x++){
768    for
769  (int y=0;y<10;y++){
770        assignationdepart(x,y,temps,4000,1000,true);// x,y,temps,
771  targetinf, targetsup, on commence par monter? true ou false
772   }
773  temps=temps+tempsentregoutte;//
774  la prochaine salve partira apres tant de ms
775  }
776  // fin d'assignation de
777  départ des gouttes
778nbrdefois=4;
779
780
781positionmoteur(targetinf);
782delay(7000);
783
784
785tempsdepart=millis();//
786  on prend le temps du départ
787
788while(aa<8){
789
790  for (int i=0;i<100;i++){//
791  on boucle pour chaque goutte, mais au moment de la première goutte on change au
792  bout d'un moment certain parametre
793
794
795if(millis()-tempsdepart>tabtiming[i]){
796  // faire comme ça plutôte que :if (millis()>tempsdepart+tabtiming[i] )   pour que
797  l'équation soit moins longue à traiter 
798
799// si on veut changer la longueure
800  d'onde en cours de route il faut recalculer le temps du trajet , la vitesse et l'acceleration
801//
802  le passage à une autre longueure d'onde ne se fait que lorsque on recommence avec
803  la première gouttequi avait démarer ici c'est la 0
804    
805if(i==0){ dd=dd+1;
806
807
808  if((dd==nbrdefois)&&(aa==1)){longueuronde=20;aa=2;dd=0;nbrdefois=2;}// 
809    
810
811  if((dd==nbrdefois)&&(aa==2)){longueuronde=15;aa=3;dd=0;nbrdefois=4;// croisement
812  de la moitié
813     for (int yy=0;yy<5;yy++){
814      for (int xx=0;xx<10;xx++){
815
816      nummoteur2=xx*10+yy;
817     
818 if(tabmontil[nummoteur2]==true){
819     tabmontil[nummoteur2]=false;}
820
821     else{
822     tabmontil[nummoteur2]=true;}}}}
823
824 if((dd==nbrdefois)&&(aa==3)){longueuronde=15;aa=4;dd=0;nbrdefois=3;//
825  fin de croisement 
826 for (int yy=0;yy<5;yy++){
827      for (int xx=0;xx<10;xx++){
828
829      nummoteur2=xx*10+yy;
830 if(tabmontil[nummoteur2]==true){
831     tabmontil[nummoteur2]=false;}
832
833     else{
834     tabmontil[nummoteur2]=true;}}}}
835 
836
837 if((dd==nbrdefois)&&(aa==4)){longueuronde=13;aa=5;dd=0;nbrdefois=2;//
838  plus bas
839     for (int jj=0;jj<100;jj++){
840    targetposinf[jj]=6000;}}
841
842   
843if((dd==nbrdefois)&&(aa==5)){longueuronde=16;aa=6;dd=0;nbrdefois=5;// croisememt
844
845     for (int jj=0;jj<100;jj++){
846     if(jj%2==0){
847     if(tabmontil[jj]==true){
848
849     tabmontil[jj]=false;}
850     else{
851     tabmontil[jj]=true; }
852      }}}
853
854     
855if((dd==nbrdefois)&&(aa==6)){longueuronde=16;aa=7;dd=0;nbrdefois=4;// arret
856  croisement     et changer la longueure d'onde la faire plus grande pour que ce soit
857  un peu plus lent 
858      for (int jj=0;jj<100;jj++){
859      if(jj%2==0){
860
861      if(tabmontil[jj]==true){
862      tabmontil[jj]=false;}
863      else{
864
865      tabmontil[jj]=true;}} } }
866
867if((dd==nbrdefois)&&(aa==7)){longueuronde=13;aa=8;dd=0;nbrdefois=2;
868  }
869//     for (int jj=0;jj<100;jj++){
870//    targetposinf[jj]=6000;}}
871      
872
873  //if((dd==nbrdefois)&&(aa==7)){longueuronde=16;aa=8;dd=0;nbrdefois=4; 
874//        //Serial.println(cc);
875  
876//     if(cc==5){aa=8;}// on fait ce bout 5x  ( ce qui fait qu'on passe 5x4=20x)
877//
878      if(bb%4==0){// on refait ce bout tous les 4x
879//        
880//      for
881  (int yy=0;yy<10;yy++){
882//      for (int xx=0;xx<10;xx++){
883//      nummoteur2=xx*10+yy;
884//
885      targetpossup[nummoteur2]=1500+1000*sin(alpha+beta);
886//      
887//      targetposinf[nummoteur2]=5000;
888//
889      beta=beta+betaincr;
890//      }
891//      alpha=alpha+alphaincr;}
892//
893    cc=cc+1;
894//   
895//      }
896//      bb=bb+1;
897//      }
898     
899
900       
901}
902
903tempsdutrajet=longueuronde*tempsentregoutte/1000;//tempsdutrajet
904  en seconde
905calculvitesseetacc (tempsdutrajet,targetposinf[i]-targetpossup[i],
906  0.15);// calcul de la vitesse et de l'accelerationn en fonction du temps du rajet
907  de la longueure du trajet et du % d'acceleration 
908 tabtiming[i]=tabtiming[i]+tempsdutrajet*1000;//
909  on repart ilfaut mettre cette instruction ici et non pas après l'envoi des commandes
910  de moteurs qui prennent un certain temps du coup certaines gouttes ont du retard
911
912
913
914  moteurplus(i,setmaxspeed,v);//
915 moteurplus(i,setmaxacceleration,ac);
916 moteurplus(i,setmaxdecceleration,ac);
917  
918//delayMicroseconds(1);// pas  variment necessaire
919 
920if(tabmontil[i]==true){
921
922  moteurplus(i,settargetposition,targetpossup[i]);
923  tabmontil[i]=false;
924
925  }
926
927 else{
928  moteurplus(i,settargetposition,targetposinf[i]);
929  tabmontil[i]=true;}
930
931  
932 
933
934
935}
936
937}
938
939
940}
941
942
943remonteretmettreazero(3);
944}
945
946
947
948
949/////////////*******************************************************************************
950
951
952void
953  vaguepastoute()
954{ 
955float targetinf=4000;
956float targetsup=1000;
957
958
959  unsigned long tempsdepart=0;// timing de l'arduino au début, il faut un unsigned
960  long sinon millis ne fonctionne pas correctement
961    
962 unsigned long temps=0;//
963  en ms la première salve de gouttes partent au bout de 0 secondes
964 unsigned
965  long tempsentregoutte=200; //en ms , pas moins de 100ms
966 //unsigned long longueuronde=20;
967  // demi longueure d'onde en goutte d'eau du prochain minimum 
968// tempsdutrajet=longueuronde*tempsentregoutte/1000;//tempsdutrajet
969  en seconde
970int aa=1;
971int bb=1; 
972int cc=1;
973
974int nummoteur2=0;
975
976
977
978while(bb<5){
979
980
981   // assignation de départ des gouttes      // dans les scénaris il faut encore
982  mettre le nbr de fois et la goutte qui est dernière et temps pour remonter à la
983  fin
984if(bb==1){scenario1departgoutte();}// nbrdefois=11; dernieregoutte=55; la
985  longieurd'onde peut être modifiée dans le scénario
986if(bb==2){scenario2departgoutte();}
987  
988if(bb==3){scenario3departgoutte();}
989if(bb==4){scenario4departgoutte(); }
990  
991  // fin d'assignation de départ des gouttes
992
993
994
995
996tempsdepart=millis();//
997  on prend le temps du départ
998
999while(aa<nbrdefois){
1000  for (int i=0;i<100;i++){//
1001  on boucle pour chaque goutte, mais au moment de la première goutte on change au
1002  bout d'un moment certain parametre
1003delayMicroseconds(1);// ça ne fonctionne pas
1004  sinon
1005
1006if(millis()>tempsdepart+tabtiming[i]){
1007
1008// si on veut changer
1009  la longueure d'onde en cours de route il faut recalculer le temps du trajet , la
1010  vitesse et l'acceleration
1011// le passage à une autre longueure d'onde ne se fait
1012  que lorsque on recommence avec la première gouttequi avait démarer ici c'est la
1013  0
1014
1015    
1016if(i==dernieregoutte){aa=aa+1;//nbrdefois+1
1017
1018//if(bb==4){//scénario
1019  4 on change le target inf à chaque fois
1020// for (int y=0;y<10;y++){
1021//    for
1022  (int x=0;x<10;x++){
1023//     nummoteur=x*10+y;
1024//  targetpossup[nummoteur]=targetpossup[nummoteur]+y*50;
1025//
1026   //targetposinf[nummoteur]=targetposinf[nummoteur]-y*50;
1027//  }}
1028//}
1029
1030}//
1031  fin de on compte nbr de fois
1032
1033
1034
1035tempsdutrajet=longueuronde*tempsentregoutte/1000;//tempsdutrajet
1036  en seconde
1037calculvitesseetacc (tempsdutrajet,targetposinf[i]-targetpossup[i],
1038  0.15);// calcul de la vitesse et de l'accelerationn en fonction du temps du rajet
1039  de la longueure du trajet et du % d'acceleration 
1040
1041 moteurplus(i,setmaxspeed,v);//
1042
1043  moteurplus(i,setmaxacceleration,ac);
1044 moteurplus(i,setmaxdecceleration,ac); 
1045delayMicroseconds(10);
1046
1047  
1048if(tabmontil[i]==true){
1049  moteurplus(i,settargetposition,targetpossup[i]);
1050
1051  tabmontil[i]=false;
1052  }
1053
1054 else{
1055  moteurplus(i,settargetposition,targetposinf[i]);
1056
1057  tabmontil[i]=true;}
1058  
1059  tabtiming[i]=tabtiming[i]+tempsdutrajet*1000;//
1060  on repart
1061
1062
1063}
1064
1065}
1066
1067}
1068bb=bb+1;//scenario suivant
1069aa=1;
1070
1071remonteretmettreazero(tempspourremonter);
1072
1073
1074
1075}
1076
1077}
1078
1079
1080
1081
1082  
1083//*******************************************************************
1084void
1085  chute()
1086{
1087 
1088float targetinf=7000;
1089float targetsup=0;
1090
1091 unsigned
1092  long tempsdepart=0;// timing de l'arduino au début, il faut un unsigned long sinon
1093  millis ne fonctionne pas correctement
1094    
1095 unsigned long temps=1000;//  en
1096  ms la première salve de gouttes partent au bout de 0 secondes
1097 unsigned long
1098  tempsentregoutte=200; //en ms , pas moins de 100ms
1099 //unsigned long longueuronde=20;
1100  // demi longueure d'onde en goutte d'eau du prochain minimum 
1101// tempsdutrajet=longueuronde*tempsentregoutte/1000;//tempsdutrajet
1102  en seconde
1103int nbrdefois=1;
1104int a=0;
1105int nummoteur=0;
1106int tabordre[100];
1107int
1108  x1=0;
1109int x2=0;
1110int c=0;
1111//scenario de chute
1112
1113
1114 for(int ii=0;ii<100;
1115  ii++) {
1116tabordre[ii]=ii;// initilaistation du tableau de l'odre de depart
1117targetposinf[ii]=targetinf;
1118targetpossup[ii]=targetsup;
1119tabmontil[ii]=false;
1120
1121}
1122
1123
1124for(long
1125  j=0;j<2560;j++){// on mélange le tableau
1126 x1=random(0,100);
1127 x2=random(0,100);
1128c=tabordre[x1];
1129tabordre[x1]=tabordre[x2];
1130tabordre[x2]=c;
1131}
1132
1133
1134
1135for(int
1136  l=0;l<5; l++) {
1137nummoteur=tabordre[l];
1138temps=temps+1000;
1139tabtiming[nummoteur]=temps;}
1140
1141for(int
1142  l=5;l<20; l++) {
1143nummoteur=tabordre[l];
1144temps=temps+500;
1145tabtiming[nummoteur]=temps;}
1146
1147for(int
1148  l=20;l<30; l++) {
1149nummoteur=tabordre[l];
1150temps=temps+400;
1151tabtiming[nummoteur]=temps;}
1152
1153for(int
1154  l=30;l<100; l++) {
1155nummoteur=tabordre[l];
1156temps=temps+200;
1157tabtiming[nummoteur]=temps;}
1158
1159
1160
1161
1162tempsdepart=millis();//
1163  on prend le temps du départ
1164
1165while(a<1){
1166  for (int i=0;i<100;i++){// on
1167  boucle pour chaque goutte, mais au moment de la première goutte on change au bout
1168  d'un moment certain parametre
1169delayMicroseconds(1);// ça ne fonctionne pas sinon
1170
1171if(millis()-tempsdepart>tabtiming[i]){
1172   
1173
1174tempsdutrajet=2;//tempsdutrajet en seconde
1175calculvitesseetacc (tempsdutrajet,targetposinf[i]-targetpossup[i],
1176  0.15);// calcul de la vitesse et de l'accelerationn en fonction du temps du rajet
1177  de la longueure du trajet et du % d'acceleration 
1178
1179 moteurplus(i,setmaxspeed,v);//
1180
1181  moteurplus(i,setmaxacceleration,ac);
1182 moteurplus(i,setmaxdecceleration,ac); 
1183delayMicroseconds(10);
1184
1185  
1186//if(tabmontil[i]==true){
1187//  moteurplus(i,settargetposition,targetpossup[i]);
1188//
1189  tabmontil[i]=false;
1190//  }
1191//
1192// else{
1193  moteurplus(i,settargetposition,targetposinf[i]);
1194
1195  // tabmontil[i]=true;
1196 // }
1197  
1198//  tabtiming[i]=tabtiming[i]+tempsdutrajet*1000;//
1199  on repart
1200
1201if(i==tabordre[99]){a=1;}// c'est fini au monent ou la dernière
1202  goutte est tombée
1203}
1204
1205}
1206
1207}
1208
1209delay(3000);
1210//remonteretmettreazero(tempspourremonter);
1211
1212
1213
1214}
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224//***************************
1225  commande avec plus que 127 moteurs*******************************
1226// dans le
1227  protocle pour communiquer avec les tic, le premier byte est toujurs complets puis
1228  ceux qui viennent après le bi 7 est toujours à 0
1229// la communciation avec les
1230  tics , si on veut utiliser plus que 127 moteurs , il faut d'abord envoyer le premier
1231  byte=0xAA, puis tous les autres seront avec le bit 7 à 0
1232// donc 2 bytes pour
1233  le numéro du device (bi7 à0), 1 byte pour le numéro de la commande (avec le bit7=0),
1234  puis 5 bytes pour les positions ou vitesse ou acceleration
1235
1236void moteurplus(int
1237  deviceNumber,uint8_t command,int32_t target)
1238{
1239//deviceNumber = 1000; //Can
1240  be anywhere from 0 to 16383
1241
1242      
1243uint8_t deviceNumberLower = deviceNumber
1244  & 0x7F;
1245uint8_t deviceNumberUpper = (deviceNumber >> 7) & 0x7F;
1246
1247//int32_t
1248  target = 200;
1249
1250
1251
1252uint8_t msb = ((target >> 7) & 1) | ((target >> 14)
1253  & 2) | ((target >> 21) & 4) | ((target >> 28) & 8);
1254uint8_t data1 = (target >>
1255  0) & 0x7F;
1256uint8_t data2 = (target >> 8) & 0x7F;
1257uint8_t data3 = (target >>
1258  16) & 0x7F;
1259uint8_t data4 = (target >> 24) & 0x7F;
1260
1261//start byte
1262Serial1.write(0xAA);
1263
1264//14-bit
1265  device number
1266Serial1.write(deviceNumberLower); 
1267Serial1.write(deviceNumberUpper);
1268
1269//0xE0
1270  command byte with MSB cleared // set target position = 0xE0
1271uint8_t commandmsbclear
1272  = command & 0x7F;
1273Serial1.write(commandmsbclear); 
1274
1275//data bytes for target
1276  position
1277Serial1.write(msb); 
1278Serial1.write(data1); 
1279Serial1.write(data2);
1280Serial1.write(data3);
1281Serial1.write(data4);
1282
1283
1284
1285
1286
1287}
1288//
1289  **********exit safe start**********
1290void exitsafedebut(int deviceNumber){
1291uint8_t
1292  deviceNumberLower = deviceNumber & 0x7F;
1293uint8_t deviceNumberUpper = (deviceNumber
1294  >> 7) & 0x7F;
1295
1296//start byte
1297Serial1.write(0xAA);
1298//14-bit device number
1299Serial1.write(deviceNumberLower);
1300  
1301Serial1.write(deviceNumberUpper);
1302
1303// command
1304Serial1.write(0x03);
1305}
1306
1307//
1308  **********set step mode**********//0 =full;1=1/2, 2=1/4,  3=1/8
1309void setstepmode(int
1310  deviceNumber, int stepmode){
1311uint8_t deviceNumberLower = deviceNumber & 0x7F;
1312uint8_t
1313  deviceNumberUpper = (deviceNumber >> 7) & 0x7F;
1314
1315//start byte
1316Serial1.write(0xAA);
1317//14-bit
1318  device number
1319Serial1.write(deviceNumberLower); 
1320Serial1.write(deviceNumberUpper);
1321
1322//
1323  command
1324Serial1.write(0x94);
1325
1326// data
1327
1328Serial1.write(stepmode);
1329
1330}
1331
1332//**********************************************************************
1333void
1334  delaiavecbluetooth(unsigned long delai)
1335{
1336unsigned long tempsdepart;
1337tempsdepart=millis();
1338while(millis()<tempsdepart+delai)
1339{
1340
1341controlbluetooth()
1342  ; // ceci fonctionne si on veut recevoir dans une variable ce ui arrive du natel
1343  format : texte=12#
1344}
1345}
1346
1347
1348
1349
1350//**********************************************************************
1351//
1352  envoi d'une chaine du natel vers le bluetooth de l'arduino
1353
1354// pour le module
1355  HC-08BLE bluetooth BT05
1356// VCC sur 5volt de l'arduino
1357// GND sur GND de l'arduino
1358//
1359  RX du module blutooth va sur le TX2 pin 16 de l'arduino, mais il passe par un pont
1360  de ressitance de220 ohms pour transformer le 5v de l'arduino en 3v
1361// TX du module
1362  bluetooth var sur le RX2  pin 17 de l'aeduino
1363// ne pas oublier d'activer le
1364  bluetoth sur le telephone
1365
1366//le natel envoie une chaine de caractère terminée
1367  par #, puis lorsque le # est atteint, il rajoute un '\\0' pour terminer la string
1368//
1369  puis il extrait le premier bout de chaine séparé de l'aure par un =
1370// exemple:
1371  "a=101#" s=1# etc  IMPORTANT le bluetoth s'appelle ALAIN si il n'apparait pas
1372  sur le natel desactiver le bluetooth et le réactiver
1373
1374void controlbluetooth(){
1375
1376  
1377  byte ndx = 0;
1378 char rc;
1379char messageFromPC[numChars] = {0};
1380 
1381
1382  while (Serial2.available() > 0 && newData == false)  {
1383
1384        rc = Serial2.read();
1385
1386        if (rc != '#') {
1387        receivedChars[ndx] = rc;
1388        ndx=ndx+1;
1389
1390   delay(100);  // si on ne met pas cette attente le while voit qu'il n'y a plus
1391  de  Serial2.available() et sort du while   
1392                
1393                  if
1394  (ndx >= numChars) {
1395                    ndx = numChars - 1;
1396                }}
1397else
1398  {
1399 
1400                receivedChars[ndx] = '\\0'; // terminate the string
1401
1402       ndx = 0;
1403       
1404 newData=true;
1405
1406 
1407 }
1408}
1409
1410
1411// reçoit
1412  "numero=101" et séparation de receivedChars en 2 chaines distinctes messageFromPC
1413  et  integer1FromPC: numéro     puis 101
1414
1415if (newData == true) {
1416 
1417char
1418  * chaine; // this is used by strtok() dont on ne sait pas à priori la longieur de
1419  chaine donc on met un * qui fait que chaine devient un pointeur vers le début de
1420  chaine
1421 strcpy(tempChars, receivedChars);// copie la string receivedChars dans
1422  tempChars
1423 chaine = strtok(tempChars,"=");   //    // obtient la première partie
1424  de la string
1425 strcpy(messageFromPC, chaine); // copy it to messageFromPC
1426
1427  chaine = strtok(NULL, "");// le Null veut dire qu'on prend toujours tempschars
1428  ez qu'on continue a chercher des delimitateurs ici ""
1429    integer0FromPC =
1430  atof(chaine);// trabsforne une chaine de caractere en float
1431
1432
1433
1434messagerecu=String(messageFromPC);//
1435  transforme la chaine de caratcetre reçu en string
1436Serial.println(messageFromPC);
1437Serial.println(
1438  integer0FromPC);
1439
1440if(messagerecu=="t"){
1441tempsdutrajet=integer0FromPC;
1442tprecedent=0;
1443  
1444t=0;
1445laps1=0;
1446laps2=0; 
1447incr=0;}
1448
1449if(messagerecu=="a"){
1450alphaincr=integer0FromPC;
1451tprecedent=0;
1452  
1453t=0;
1454laps1=0;
1455laps2=0; 
1456incr=0;}
1457
1458if(messagerecu=="s"){
1459remonteretmettreazero(23);
1460}
1461
1462
1463
1464//Serial.println(
1465  tempsdutrajet);
1466//Serial.println(  alphaincr);
1467
1468}
1469newData=false;
1470
1471}
1472
1473
1474//***********************************************************************************
1475//***********************************************************************************
1476//****
1477  Chenille  ******************
1478//***********************************************************************************
1479
1480void
1481  chenille(){
1482
1483int longueurchenille=2;
1484int xchenille[longueurchenille];
1485int
1486  ychenille[longueurchenille];
1487int xincrement=1;
1488int yincrement=1;
1489int x=0;
1490int
1491  y=0;
1492float tempstrajetavant=0.5;
1493
1494for(int k=0;k<longueurchenille;k++){
1495xchenille[k]=x-k;
1496ychenille[k]=y-k;}
1497float
1498  target=5000;
1499  
1500
1501for(int i=0;i<100;i++){
1502targetprochain[i]=target;
1503targetpreced[i]=target;
1504}
1505
1506positionmoteur(target);
1507delay(12000);
1508
1509xincrement=1;
1510yincrement=0;
1511for(int
1512  ii=0;ii<1000;ii++){
1513
1514if(ii%5==0){
1515xincrement=(random(0,199)%3)-1;
1516yincrement=(random(0,300)%3)-1;
1517}
1518
1519
1520if(((xchenille[0]+xincrement)!=xchenille[0])|((ychenille[0]+yincrement)!=ychenille[0])){
1521if(((xchenille[0]+xincrement)!=xchenille[1])|((ychenille[0]+yincrement)!=ychenille[1])){
1522
1523
1524
1525
1526targetprochain[xchenille[0]]=target-1000;
1527
1528unmoteuracetteposition(xchenille[0],
1529  ychenille[0], tempstrajetavant,targetprochain[xchenille[0]], target);// on monte
1530  l'avant     unmoteuracetteposition( int x, int y, float tempstrajet, float newtarget,
1531  float targetprecedent)
1532
1533unmoteuracetteposition(xchenille[longueurchenille-1],
1534  ychenille[longueurchenille-1], tempstrajetavant+0.5,target,targetpreced[xchenille[longueurchenille-1]]);//
1535  on descend l'arrière
1536
1537targetpreced[xchenille[0]]=targetprochain[xchenille[0]];
1538
1539
1540for(int
1541  i=longueurchenille-1;i>0;i--){// décalage de tous les élements de la chenille
1542xchenille[i]=xchenille[i-1];
1543ychenille[i]=ychenille[i-1];
1544targetpreced[i]=targetpreced[i-1];
1545}
1546
1547xchenille[0]=xchenille[0]+xincrement;
1548ychenille[0]=ychenille[0]+yincrement;
1549
1550//if(xchenille[0]<0){xchenille[0]=9;}
1551//if(xchenille[0]>9){xchenille[0]=0;}
1552//if(ychenille[0]<0){ychenille[0]=9;}
1553//if(ychenille[0]>9){ychenille[0]=0;}
1554
1555if(xchenille[0]<0){xchenille[0]=0;}
1556if(xchenille[0]>9){xchenille[0]=9;}
1557if(ychenille[0]<0){ychenille[0]=0;}
1558if(ychenille[0]>9){ychenille[0]=9;}
1559
1560//if(xchenille[0]>8){xincrement=0;yincrement=1;}
1561//if(xchenille[0]>9){xchenille[0]=0;}
1562//if(ychenille[0]<0){ychenille[0]=9;}
1563//if(ychenille[0]>9){ychenille[0]=0;}
1564
1565alpha=alpha+alphaincr;
1566delay(tempstrajetavant*1000/longueurchenille);
1567
1568}}
1569
1570}
1571positionmoteur(target);
1572delay(12000);
1573
1574}
1575
1576
1577
1578
1579
1580
1581
1582//*******************************
1583  calcul de la vitesse et de l'acceleration en fonction du temps du trajet de la longieure
1584  du trajet et du % d'acceleration
1585
1586
1587void calculvitesseetacc (float tempstrajet,
1588  float longueuretrajet, float fraxacc)
1589{
1590  frax=0.15;// c'est à dire 20% dutrajet
1591  en acceleration; 60% en vitesse constante et 20% en deceleration, maximum c'est
1592  0.5
1593// en fait pour de court trajet genre sinus (alpha =alpha+01, il faut mettre
1594  frax au minimum=0.001
1595//ça marche bien avec 0.2 et un délai plus court entre
1596  chaque salve de commande
1597// a= Path/(t au carré *frax*(1-frax))
1598// a*t*frax=v
1599float
1600  tinter=tempstrajet*tempstrajet;
1601tinter=tinter*fraxacc; 
1602tinter=tinter*(1-fraxacc);
1603float
1604  tinter2=tempstrajet*fraxacc;
1605
1606ac=longueuretrajet/tinter;
1607v=ac*tinter2;
1608ac=ac*100;
1609v=v*10000;
1610
1611}
1612
1613//***********************************
1614  1moteuracette position en un temps donné en fonction de la nouvelle positioon et
1615  de l'ancienne
1616
1617void unmoteuracetteposition( int x, int y, float tempstrajet,
1618  float newtarget, float targetprecedent)
1619{
1620
1621 if((x>-1)&&(x<10)){
1622  if
1623  ((y>-1)&&(y<10)){
1624
1625
1626calculvitesseetacc(tempstrajet,abs(newtarget-targetprecedent),0.15);
1627
1628  int nummoteur=x*10+y;
1629 moteurplus(nummoteur,setmaxspeed,v);//
1630 moteurplus(nummoteur,setmaxacceleration,ac);
1631
1632  moteurplus(nummoteur,setmaxdecceleration,ac); 
1633delayMicroseconds(10);
1634 moteurplus(nummoteur,settargetposition,newtarget);
1635}
1636
1637  }
1638 }
1639// ********************************************* assignation départ des
1640  timing gouttes
1641void assignationdepart(int x, int y, unsigned long temps, float
1642  targetinf, float targetsup, bool monte)
1643{
1644    if((x>=0)&&(x<10)){
1645      if((y>=0)&&(y<10)){
1646
1647    nummoteur=x*10+y;
1648  tabtiming[nummoteur]=temps;
1649  tabmontil[nummoteur]=monte;//
1650  les gouttes vont monter
1651  targetpossup[nummoteur]=targetsup;
1652  targetposinf[nummoteur]=targetinf;
1653  
1654    }}
1655}
1656// ***********************************************************************************************
1657void
1658  scenario1departgoutte()
1659
1660{// assignation de départ des gouttes
1661 unsigned
1662  long temps=0;//  en ms la première salve de gouttes partent au bout de 0 secondes
1663
1664  unsigned long tempsentregoutte=200; //en ms , pas moins de 100ms
1665 nbrdefois=7;
1666
1667  dernieregoutte=55;
1668 tempspourremonter=8;
1669 longueuronde=16;
1670  
1671 for (int
1672  y=0;y<10;y++){
1673    for (int x=0;x<2;x++){assignationdepart(x,y,temps,4000,1000,false)
1674  ;}  //(int x, int y, unsigned long temps, float targetinf, float targetsup, bool
1675  monte)
1676    temps=temps+tempsentregoutte;}// la prochaine salve partira apres
1677  tant de ms
1678
1679 for (int x=2;x<10;x++){
1680    for (int y=8;y<10;y++){assignationdepart(x,y,temps,4000,1000,false)
1681  ;}  //(int x, int y, unsigned long temps, float targetinf, float targetsup, bool
1682  monte)
1683    temps=temps+tempsentregoutte;}// la prochaine salve partira apres
1684  tant de ms
1685
1686 for (int y=7;y>-1;y--){
1687    for (int x=8;x<10;x++){assignationdepart(x,y,temps,4000,1000,false)
1688  ;}  //(int x, int y, unsigned long temps, float targetinf, float targetsup, bool
1689  monte)
1690    temps=temps+tempsentregoutte;}// la prochaine salve partira apres
1691  tant de ms
1692
1693 for (int x=7;x>1;x--){
1694    for (int y=0;y<2;y++){assignationdepart(x,y,temps,4000,1000,false)
1695  ;}  //(int x, int y, unsigned long temps, float targetinf, float targetsup, bool
1696  monte)
1697    temps=temps+tempsentregoutte;}// la prochaine salve partira apres
1698  tant de ms
1699
1700
1701 temps=temps+tempsentregoutte;
1702  temps=temps+tempsentregoutte;
1703
1704  temps=temps+tempsentregoutte;// un délai plus long avant que celles du milieu
1705  descencent
1706 for (int y=3;y<7;y++){
1707    for (int x=3;x<7;x++){assignationdepart(x,y,temps,6000,500,false)
1708  ;}  //(int x, int y, unsigned long temps, float targetinf, float targetsup, bool
1709  monte)
1710  }// la prochaine salve partira apres tant de ms
1711    
1712  // fin
1713  d'assignation de départ des gouttes
1714}
1715
1716// ***********************************************************************************************
1717void
1718  scenario2departgoutte()
1719
1720{// assignation de départ des gouttes
1721 unsigned
1722  long temps=0;//  en ms la première salve de gouttes partent au bout de 0 secondes
1723
1724  unsigned long tempsentregoutte=800; //en ms , pas moins de 100ms
1725 nbrdefois=5;
1726
1727  dernieregoutte=55;
1728 tempspourremonter=11;
1729  longueuronde=20;
1730  
1731 for
1732  (int y=0;y<10;y++){
1733    assignationdepart(0,y,temps,4000,1000,false) ;//(int
1734  x, int y, unsigned long temps, float targetinf, float targetsup, bool monte)
1735
1736     assignationdepart(9,y,temps,4000,1000,false) ;}  
1737 for (int x=1;x<9;x++){
1738
1739    assignationdepart(x,0,temps,4000,1000,false) ;//(int x, int y, unsigned long
1740  temps, float targetinf, float targetsup, bool monte)
1741     assignationdepart(x,9,temps,4000,1000,false)
1742  ;}
1743 temps=temps+tempsentregoutte;// la prochaine salve partira apres tant de
1744  ms
1745
1746 for (int y=1;y<9;y++){
1747    assignationdepart(1,y,temps,5000,1000,false)
1748  ;//(int x, int y, unsigned long temps, float targetinf, float targetsup, bool monte)
1749
1750     assignationdepart(8,y,temps,5000,1000,false) ;}  
1751 for (int x=2;x<8;x++){
1752
1753    assignationdepart(x,1,temps,5000,1000,false) ;//(int x, int y, unsigned long
1754  temps, float targetinf, float targetsup, bool monte)
1755     assignationdepart(x,8,temps,5000,1000,false)
1756  ;}
1757 temps=temps+tempsentregoutte;// la prochaine salve partira apres tant de
1758  ms
1759
1760  for (int y=2;y<8;y++){
1761    assignationdepart(2,y,temps,6000,1000,false)
1762  ;//(int x, int y, unsigned long temps, float targetinf, float targetsup, bool monte)
1763
1764     assignationdepart(7,y,temps,6000,1000,false) ;}  
1765 for (int x=3;x<7;x++){
1766
1767    assignationdepart(x,2,temps,6000,1000,false) ;//(int x, int y, unsigned long
1768  temps, float targetinf, float targetsup, bool monte)
1769     assignationdepart(x,7,temps,6000,1000,false)
1770  ;}
1771 temps=temps+tempsentregoutte;// la prochaine salve partira apres tant de
1772  ms
1773
1774  for (int y=3;y<7;y++){
1775    assignationdepart(3,y,temps,7000,1000,false)
1776  ;//(int x, int y, unsigned long temps, float targetinf, float targetsup, bool monte)
1777
1778     assignationdepart(6,y,temps,7000,1000,false) ;}  
1779 for (int x=4;x<6;x++){
1780
1781    assignationdepart(x,3,temps,7000,1000,false) ;//(int x, int y, unsigned long
1782  temps, float targetinf, float targetsup, bool monte)
1783     assignationdepart(x,6,temps,7000,1000,false)
1784  ;}
1785 temps=temps+tempsentregoutte;// la prochaine salve partira apres tant de
1786  ms
1787   
1788   for (int y=4;y<6;y++){
1789    assignationdepart(4,y,temps,7500,1000,false)
1790  ;//(int x, int y, unsigned long temps, float targetinf, float targetsup, bool monte)
1791
1792     assignationdepart(5,y,temps,7500,1000,false) ;}  
1793assignationdepart(5,4,temps,7500,1000,false)
1794  ;
1795assignationdepart(5,5,temps,7500,1000,false) ;
1796 //temps=temps+tempsentregoutte;//
1797  la prochaine salve partira apres tant de ms
1798    
1799}
1800
1801// ***********************************************************************************************
1802void
1803  scenario3departgoutte()
1804
1805{// assignation de départ des gouttes
1806 unsigned
1807  long temps=0;//  en ms la première salve de gouttes partent au bout de 0 secondes
1808
1809  unsigned long tempsentregoutte=1000; //en ms , pas moins de 100ms
1810 
1811 nbrdefois=5;
1812
1813  dernieregoutte=45;
1814 tempspourremonter=8;
1815 longueuronde=20;
1816 // drawCircle(int
1817  x0, int y0, int r,  unsigned long temps, float targetinf, float targetsup, bool
1818  monte)
1819
1820 drawCircle(5, 5, 4, temps, 4000, 1000, false);
1821temps=temps+tempsentregoutte;//
1822  la prochaine salve partira apres tant de ms
1823 drawCircle(5, 5, 3, temps, 4500,
1824  1000, false);
1825temps=temps+tempsentregoutte;// la prochaine salve partira apres
1826  tant de ms
1827 drawCircle(5, 5, 2, temps, 5000, 1000, false);
1828temps=temps+tempsentregoutte;//
1829  la prochaine salve partira apres tant de ms
1830 drawCircle(5, 5, 1, temps, 5500,
1831  1000, false);
1832
1833
1834
1835
1836// drawCircle(0, 0, 4, temps, 4000, 1000, false);
1837//
1838  drawCircle(9, 9, 4, temps, 4000, 1000, false);
1839//drawCircle(0, 9, 4, temps,
1840  4000, 1000, false);
1841//  drawCircle(9, 0, 4, temps, 4000, 1000, false);
1842//temps=temps+tempsentregoutte;//
1843  la prochaine salve partira apres tant de ms
1844//
1845// drawCircle(0, 0, 3, temps,
1846  4000, 1000, false);
1847//  drawCircle(9, 9, 3, temps, 4000, 1000, false);
1848//drawCircle(0,
1849  9, 3, temps, 4000, 1000, false);
1850//  drawCircle(9, 0, 3, temps, 4000, 1000, false);
1851//temps=temps+tempsentregoutte;//
1852  la prochaine salve partira apres tant de ms
1853//
1854// drawCircle(0, 0, 2, temps,
1855  4000, 1000, false);
1856//  drawCircle(9, 9, 2, temps, 4000, 1000, false);
1857//drawCircle(0,
1858  9, 2, temps, 4000, 1000, false);
1859//  drawCircle(9, 0, 2, temps, 4000, 1000, false);
1860//temps=temps+tempsentregoutte;//
1861  la prochaine salve partira apres tant de ms
1862
1863
1864
1865
1866    
1867  // fin
1868  d'assignation de départ des gouttes
1869}
1870
1871// ***********************************************************************************************
1872void
1873  scenario4departgoutte()
1874//
1875{// assignation de départ des gouttes
1876 unsigned
1877  long temps=0;//  en ms la première salve de gouttes partent au bout de 0 secondes
1878
1879  unsigned long tempsentregoutte=200; //en ms , pas moins de 100ms
1880 nbrdefois=11;
1881
1882  dernieregoutte=0;
1883 tempspourremonter=12.5;
1884  longueuronde=20;
1885//writeLine(byte
1886  x0, byte y0, byte x1, byte y1, unsigned long temps, float targetinf, float targetsup,
1887  bool monte)
1888
1889writeLine (0,0,9,0,temps,4000,2000,false);
1890temps=temps+tempsentregoutte;//
1891  la prochaine salve partira apres tant de ms
1892
1893writeLine(0,1,9,1,temps,4500,2000,false);
1894temps=temps+tempsentregoutte;//
1895  la prochaine salve partira apres tant de ms
1896
1897writeLine(0,2,9,2,temps,5000,2000,false);
1898temps=temps+tempsentregoutte;//
1899  la prochaine salve partira apres tant de ms
1900
1901writeLine(0,3,9,3,temps,5500,2000,false);
1902temps=temps+tempsentregoutte;//
1903  la prochaine salve partira apres tant de ms
1904
1905writeLine(0,4,9,4,temps,6000,2000,false);
1906temps=temps+tempsentregoutte;//
1907  la prochaine salve partira apres tant de ms
1908
1909writeLine(0,5,9,5,temps,6500,2000,false);
1910temps=temps+tempsentregoutte;//
1911  la prochaine salve partira apres tant de ms
1912
1913writeLine(0,6,9,6,temps,7000,2000,false);
1914temps=temps+tempsentregoutte;//
1915  la prochaine salve partira apres tant de ms
1916
1917writeLine(0,7,9,7,temps,7500,2000,false);
1918temps=temps+tempsentregoutte;//
1919  la prochaine salve partira apres tant de ms
1920
1921writeLine(0,8,9,8,temps,8000,2000,false);
1922temps=temps+tempsentregoutte;//
1923  la prochaine salve partira apres tant de ms
1924
1925writeLine(0,9,9,9,temps,8500,2000,false);
1926temps=temps+tempsentregoutte;//
1927  la prochaine salve partira apres tant de ms
1928
1929
1930
1931}
1932
1933
1934
1935
1936
1937
1938//
1939  cercle
1940//*************************************************************************************
1941
1942//
1943  assignation des temps de départ en cercle
1944
1945void drawCircle(int x0, int y0,
1946  int r,  unsigned long temps, float targetinf, float targetsup, bool monte) {
1947
1948  if(r>0){
1949    int f = 1 - r;
1950    int ddF_x = 1;
1951    int ddF_y = -2 * r;
1952
1953    int x = 0;
1954    int y = r;
1955
1956
1957assignationdepart(x0, y0 + r,temps,targetinf,targetsup,monte);
1958assignationdepart(x0,
1959  y0 - r,temps,targetinf,targetsup,monte);
1960assignationdepart(x0+r, y0,temps,targetinf,targetsup,monte);
1961assignationdepart(x0-r,
1962  y0,temps,targetinf,targetsup,monte);
1963
1964
1965
1966    while (x<y) {
1967        if
1968  (f >= 0) {
1969            y--;
1970            ddF_y += 2;
1971            f += ddF_y;
1972
1973        }
1974        x++;
1975        ddF_x += 2;
1976        f += ddF_x;
1977assignationdepart(x0,
1978  y0 + r,temps,targetinf,targetsup,monte);
1979        
1980assignationdepart(x0+x,
1981  y0 + y,temps,targetinf,targetsup,monte);
1982assignationdepart(x0-x, y0 + y,temps,targetinf,targetsup,monte);
1983assignationdepart(x0+x,
1984  y0 - y,temps,targetinf,targetsup,monte);
1985assignationdepart(x0-x, y0 - y,temps,targetinf,targetsup,monte);
1986assignationdepart(x0+y,
1987  y0 + x,temps,targetinf,targetsup,monte);
1988assignationdepart(x0-y, y0 + x,temps,targetinf,targetsup,monte);
1989assignationdepart(x0+y,
1990  y0 - x,temps,targetinf,targetsup,monte);
1991assignationdepart(x0-y, y0 - x,temps,targetinf,targetsup,monte);
1992
1993
1994    }
1995  }
1996}
1997
1998
1999//**************************************************************************/
2000/*!
2001
2002   @brief    Write a line.  Bresenham's algorithm - thx wikpedia
2003    @param    x0
2004  Start point x coordinate
2005    @param    y0  Start point y coordinate
2006    @param
2007    x1  End point x coordinate
2008    @param    y1  End point y coordinate
2009    @param
2010    color 16-bit 5-6-5 Color to draw with
2011*/
2012//**************************************************************************
2013
2014void
2015  writeLine(int x0, int y0, int x1, int y1, unsigned long temps, float targetinf,
2016  float targetsup, bool monte) {
2017
2018
2019if((x0==x1)or(y0==y1)){
2020
2021if(y0==y1){//
2022  on dessine une ligne horizontale
2023byte longeur=abs(x1-x0)+1;
2024for(byte x=0;x<longeur;x++){
2025
2026   assignationdepart(x+x0, y0,temps,targetinf,targetsup,monte);  }}
2027
2028
2029else{//
2030  on dessine une ligne verticale
2031    byte longueur=abs(y1-y0)+1;
2032for(byte y=0;
2033  y<longueur; y++){
2034 
2035  assignationdepart(x0, y+y0,temps,targetinf,targetsup,monte);}
2036
2037}
2038
2039
2040  
2041}
2042else{// c'est ni une horizontale ni une verticale
2043    int steep = abs(y1
2044  - y0) > abs(x1 - x0);
2045  
2046    if (steep) {
2047        swap(x0, y0);
2048        swap(x1,
2049  y1);
2050    }
2051
2052    if (x0 > x1) {
2053        swap(x0, x1);
2054        swap(y0,
2055  y1);
2056    }
2057
2058    int dx, dy;
2059    dx = x1 - x0;
2060    dy = abs(y1 - y0);
2061
2062
2063    int err = dx / 2;
2064    int ystep;
2065
2066    if (y0 < y1) {
2067        ystep
2068  = 1;
2069    } else {
2070        ystep = -1;
2071    }
2072
2073    for (; x0<=x1; x0++)
2074  {
2075        if (steep) {
2076     
2077         assignationdepart(y0, x0,temps,targetinf,targetsup,monte);
2078
2079
2080    
2081        } else {
2082            
2083          assignationdepart(x0, y0,temps,targetinf,targetsup,monte);
2084
2085        
2086        }
2087        err -= dy;
2088        if (err < 0) {
2089            y0
2090  += ystep;
2091            err += dx;
2092        }
2093    }
2094}
2095}