Discussion :

[méphistopheles]

Bonjour.

Suite à ce post j'ai effectué une implémentation du problème. (je remet la figure) :

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
if(t>=p)
{
	if(t+1>=t2)
 	{
 		speed=C-sum;
 		return 1;
 	}
 	speed-=decc_pos;
}
else
{
 	speed+=acc_pos;
        if(speed>h)
             speed=h;
}
sum+=speed;

avec acc_pos(a0), la première pente et decc_pos(a2) la seconde; h est la hauteur du point en p; C est la consigne. ce code étant exécuté a chaque fois avec un t incrémenté de 1.

Les temps sont calculés de la façon suivante (en double) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
t2=sqrt(2C*(acc_pos+decc_pos))/(acc_pos*decc_pos));
h=2C/sf->t2;
t0=h/acc_pos;

par la suite, on convertit t1 et t2 en int.
Le problème est que quand je teste avec la discrétisation de t2 et t0 (car t discret), j'obtiens, pour acc_pos_==decc_pos=5 C=5820 le résultat suivant:


de même, avec C=582:


Les pics correspondant à l'ajustement de l'intégrale.
c'est clairement un problème de discrétisation... plus précisément, cela se produit car la diminution (t0) commence trop tôt ou trop tard.

Si vous avez une idée...

merci

[méphistopheles]

Suite à une discussion avec sehnsucht sur le chat, il semblerais que je me sois mal expliqué. Ici, a0,a2 et C sont connus. t0 et t2 sont calculable (et calculés) mais ne sont pas entiers. or t, lui est entier. Du coup au lieu d'avoir une belle courbe affine, ma véritable courbe de sortie est une courbe en escalier.

Pour illustrer ce propos, j'ai, ci dessous retracé la première courbe avec l'allure réelle de ma courbe :


En théorie, on ne devrai spas avoir de changements mageurs dû a cette discrétisation... sauf que au sommet du triangle on a un dépassement (ou au contraire on commence à redescendre trop tôt) qui entraine un dépassement de C (ou un retard sur C) d'une valeur comprise entre 0 et h...

Ce n'est pas grave si l'on doit induire une courbe corrective à la fin tant que C est atteint sans dépassement, mais il faudrait éviter d'avoir un changement de signe de l'accélération (c'est une courbe de vitesse).

Si vous avez une idée...


Merci

[pseudocode]

Méthode 1 : conserver les pentes actuelles et faire un plateau en haut du triangle.

Méthode 2 : faire de l'asservissement pour avoir (en moyenne) les pentes exactes.

[méphistopheles]

j'aurais tendence à utiliser la méthode 2 à partir d'un temps t=t2-x, mais le cas 2 me trouble: je ne comprend pas comment je fais pour faire un dépassement de la consigne avec l'algo actuel....

[pseudocode]

j'aurais tendence à utiliser la méthode 2 à partir d'un temps t=t2-x, mais le cas 2 me trouble: je ne comprend pas comment je fais pour faire un dépassement de la consigne avec l'algo actuel....

Ton problème ressemble fort a un asservissement en position. C'est un sujet sur lequel il y a beaucoup de documentation (régulateurs PID, ...).

Un moyen simple pour résoudre ton problème est de regarder à chaque étape (t) si tu as le temps de freiner avant de dépasser la consigne.

Exemple trivial (qui va causer des "rebonds" à la fin):

Code java :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
int C = 5820;
int acc = 5;
int dec = 5;
 
int pos=0, speed=0;
for(int t=0;;t++) {
	// remaining distance
	int remain = C - pos;
 
	// time to slowdown ?
	int remain_next = remain-speed;
	int speed_next = speed+acc;
	if ( remain_next*2*dec < speed_next*speed_next ) {
		speed-=dec;
	} else {
		speed+=acc;
	}
	pos+=speed;
 
	System.out.printf("t=%02d : speed=%02d pos=%04d\n",t,speed,pos);
	if (remain<=0) break;
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
t=00 : speed=05 pos=0005
t=01 : speed=10 pos=0015
t=02 : speed=15 pos=0030
t=03 : speed=20 pos=0050
t=04 : speed=25 pos=0075
t=05 : speed=30 pos=0105
t=06 : speed=35 pos=0140
t=07 : speed=40 pos=0180
t=08 : speed=45 pos=0225
t=09 : speed=50 pos=0275
t=10 : speed=55 pos=0330
t=11 : speed=60 pos=0390
t=12 : speed=65 pos=0455
t=13 : speed=70 pos=0525
t=14 : speed=75 pos=0600
t=15 : speed=80 pos=0680
t=16 : speed=85 pos=0765
t=17 : speed=90 pos=0855
t=18 : speed=95 pos=0950
t=19 : speed=100 pos=1050
t=20 : speed=105 pos=1155
t=21 : speed=110 pos=1265
t=22 : speed=115 pos=1380
t=23 : speed=120 pos=1500
t=24 : speed=125 pos=1625
t=25 : speed=130 pos=1755
t=26 : speed=135 pos=1890
t=27 : speed=140 pos=2030
t=28 : speed=145 pos=2175
t=29 : speed=150 pos=2325
t=30 : speed=155 pos=2480
t=31 : speed=160 pos=2640
t=32 : speed=165 pos=2805
t=33 : speed=160 pos=2965
t=34 : speed=155 pos=3120
t=35 : speed=150 pos=3270
t=36 : speed=145 pos=3415
t=37 : speed=150 pos=3565
t=38 : speed=145 pos=3710
t=39 : speed=140 pos=3850
t=40 : speed=135 pos=3985
t=41 : speed=130 pos=4115
t=42 : speed=125 pos=4240
t=43 : speed=120 pos=4360
t=44 : speed=115 pos=4475
t=45 : speed=110 pos=4585
t=46 : speed=105 pos=4690
t=47 : speed=100 pos=4790
t=48 : speed=95 pos=4885
t=49 : speed=90 pos=4975
t=50 : speed=85 pos=5060
t=51 : speed=80 pos=5140
t=52 : speed=75 pos=5215
t=53 : speed=70 pos=5285
t=54 : speed=65 pos=5350
t=55 : speed=60 pos=5410
t=56 : speed=55 pos=5465
t=57 : speed=50 pos=5515
t=58 : speed=45 pos=5560
t=59 : speed=40 pos=5600
t=60 : speed=35 pos=5635
t=61 : speed=30 pos=5665
t=62 : speed=35 pos=5700
t=63 : speed=30 pos=5730
t=64 : speed=25 pos=5755
t=65 : speed=20 pos=5775
t=66 : speed=15 pos=5790
t=67 : speed=10 pos=5800
t=68 : speed=05 pos=5805
t=69 : speed=10 pos=5815
t=70 : speed=05 pos=5820
t=71 : speed=00 pos=5820

[diogene]

On peut réaliser directement une surface donnée délimitée par un (quasi)triangle isocèle.
On prend pour unité de surface le "pas de discrétisation vertical X pas de discrétisation horizontal".
si on réalise la courbe

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
           _
         _| |_
       _|     |_
     _|         |_
   _|             |_
 i=0 1 2 3 4 5 6 7 8 
         n       ^---2n+1

La séquence commence en i = 0, croît avec un incrément de 1 jusqu'à i = n et décroît avec un incrément de -1 de n+1 jusqu'à 0 (avec dans l'exemple n = 3). La surface est (n+1)^2, et le maximum est h = n+1 (dans l'exemple, 16 et 4)

Si en position p, au lieu de faire un incrément vertical de +1, on fait un incrément vertical de +2, alors la surface est accrue de 2n+3-p et la surface devient (n+2)^2-p avec 0<p<2n+3. Pour p=0 ou p=2n+3, la surface est de la forme N^2, et on est dans le cas précédent. La séquence se termine en 2n+2. Le maximum est n+1 ou n+2 selon la valeur de p par rapport à n+1.

Si on veut obtenir une surface C, écrire C = (n+2)^2-p avec 0<p<2n+3

Par exemple,
- pour obtenir une surface de S = 23 : sqrt(23) = 4,... et n+2 = 5, n = 3, p = 5^2-23 = 2
- pour obtenir une surface de S = 18 : sqrt(18) = 4,... et n+2 = 5, n = 3, p = 5^2-18 = 7

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
           _                           
         _|_|_                       _                  
       _|_| |_|_                   _| |_
      |_|     |_|_               _|     |_ _
     _|         |_|_           _|         |_|_
   _|             |_|_       _|             |_|_
 i=0 1 2 3 4 5 6 7 8 9       0 1 2 3 4 5 6 7 8 9
       p n       ^---2n+1          n       p
S = 23                       S = 18

Pour S = 5820 = 77^2-109, on a n= 75, p = 109 mais je ne fais pas le dessin !

[méphistopheles]

Bonsoir.

Je m'excuse de répondre si tard, j'ai dû régler quelques autres problèmes urgents avant de revenir là dessus.

Si je n'ai pas appliqué la méthode d'asservissement, proposée par pseudocode, c'est que je disposait déjà d'une telle méthode, mais que celle-ci impliquait des temps de calculs trops importants. C'est dailleurs pour ça que je cherchait à précalculer mes valeurs.

Il aurait aussi été possible de faire une méthode mixte (asservir à partir de p seulement), mais j'avais besoin d'un temps de calcul constant.

En ce qui concerne la méthode de diogène, c'est en effet la méthode idéale, mais je dois avouer ne pas avoir eu le temps de l'implémenter.


J'ai en effet été, en pratique, confronté à des accélérations et de vitesses tres faibles comparées à la taille de la pwm, ce qui a rendu l'erreur négligeable.

Toutefois, si j'ai le temps, j'essayerais d'implémenter la méthode de digoène qui est vraiment mieux.

Merci