Discussion :

[fred7]

Bonjour à tous,

Je galère sur un petit bout de mon programme et là j'avoue que sans aide extérieure, des idées fraîches , je n'y arriverai pas.

Pour le background je peux dire que mon projet est un petit robot qui met en œuvre 2 compteurs (roue droite et gauche) qui servent à compter la distance et le sens de rotation. Ces compteurs comptent entre 0 et 65535. Si ils arrivent à 65535 ils retournent à 0. De la même manière si une roue recule le compteur décompte.

J'ai donc besoin d'une variable qui évolue entre -32767 et 32767 pour l'asservissement en position et, c'est là qu'est mon problème, d'une seconde variable qui évolue toujours positivement (même si le robot recule et que les compteurs décomptent) pour l'asservissement en vitesse.

par exemple si le compteur évolue de la sorte : 1, 2, 4, 3, 1, 65530, 65500
alors la variable pour l'asser en position donne: 1, 2, 4, 3, 1, -5, -35
puis la variable pour l'asserv en vitesse donne: 1, 2, 4, 5, 7, 12, 42
(Légende : Rouge : valeur qui croît; Bleu : valeur qui décroît)

Voici la fonction que j'ai réalisé jusqu'à présent. Pour incrémenter constamment ces variables de vitesse (CmptVD et CmptVG) j'ai tenté une comparaison entre l'itération actuelle et précédente mais la variable décroit tout de même. C'est un échec.

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
 
//---------------------------------------------------------------------------
// 							FONCTION COMPTAGE 								-
//	En entrée : compteurs hardware ls7366 allant de 0 à 65535				-
//	En sortie : CmptD, CmptG allant de -32767 à +32767						-
//				CmptVG, CmptVG allant de 0 à 65535 quelque soit le sens 	-
//
//					   [0]------------------------[65535]>		-
//			<[-32767]----------[0]----------[32767]>					-
//---------------------------------------------------------------------------
void Comptage(void)
{
 
	CmptD = Qcntr_Read(QcntrD); // charger le compteur Droit
	CmptG = Qcntr_Read(QcntrG);
	CmptVD = CmptD;
	CmptVG = CmptG;
 
//---------- variable asservissement position
		if (Qcntr_Read_Sens(QcntrD) == 0) 							// AVANCER
		{
			if (CmptD > 32767){CmptD = 0;}							// et dépasser 32767 = retour à 0
		} 
			else 													// RECULER
			{
				if (CmptD > 32767){CmptD = CmptD - 65535;}			// et dépasser 32767 = compter sous 0
				if (CmptD < -32767){CmptD = 0;}
			}
 
 
		if (Qcntr_Read_Sens(QcntrG) == 0) 							// AVANCER
		{
			if (CmptG > 32767){CmptG = 0;}							// et dépasser 32767
		} 
			else 													// RECULER
			{
				if (CmptG > 32767){CmptG = CmptG - 65535;}			// et dépasser 32767
				if (CmptG < -32767){CmptG = 0;}
			}
 
//---------- variable asservissement vitesse
	if (CmptD < OldCmptD )  { CmptVD += CmptVD + (OldCmptD - CmptD) ; } else {CmptVD = CmptD;}  // calculer compteur vitesse
	OldCmptD = CmptD; // actualiser itération précédente
 
}

Merci à vous!

[Matt_Houston]

Il nous manque le plus important : les déclarations et donc les types des variables entières que tu manipules.

Tu peux t'en sortir en détournant à ton profit le dépassement de capacité d'un entier - integer overflow, en anglais - sur des variables de type uint16_t (defini dans stdint.h / inttypes.h). Attention : en C le comportement d'un dépassement n'est défini que pour des opérations arithmétiques sur des entiers non signés. Il faudra ajouter une petit manip afin d'obtenir une variable bouclant entre -32767 (-32768 ?) et +32767.

[fred7]

Il nous manque le plus important : les déclarations et donc les types des variables entières que tu manipules.

Code :

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

1
2
3
4
 
float CmptG, CmptVG ; 		// Compteur position gauche, compteur vitesse gauche
float CmptD, CmptVD ;
float OldCmptD , OldCmptG ;

[Matt_Houston]

Une raison particulière pour en faire des float ?

Code :

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

1
2
3
4
5
6
7
8
if (CmptD > 32767)
{
    CmptD = CmptD - 65535;
}
if (CmptD < -32767)
{
    CmptD = 0;
}

Ces deux blocs :

• sont interdépendants (peut-être faudrait-il un else ?) ;
• ne sont pas symétriques du point de vue logique : les deux traitements ne sont pas équivalents.

Tu as du code dupliqué : fais une fonction si tu dois appliquer l'invariant à plus d'une variable.

[fred7]

Pas de raison particulière non.

Tu as du code dupliqué : fais une fonction si tu dois appliquer l'invariant à plus d'une variable.

Pardon mais je ne comprend pas cette phrase.

De toute manière ce qui m’amène ici c'est l'autre partie du programme qui concerne la variable CmptVD :

Code :

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

1
2
3
//---------- variable asservissement vitesse
	if (CmptD < OldCmptD )  { CmptVD = CmptVD + (OldCmptD - CmptD) ; } else {CmptVD = CmptD;}  // calculer compteur vitesse
	OldCmptD = CmptD; // actualiser itération précédente

[Kannagi]

Pas de raison particulière non.

Alors ne les utilise pas les float sont fait pour faire des calculs mathématique plus poussé , mais ne sont pas très précis les comparaison avec des nombre entier peut causer quelque souci.

Sinon :

Code :

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

1
2
3
4
5
6
7
if (CmptD > 32767){CmptD = 0;}							// et dépasser 32767 = retour à 0
		} 
			else 													// RECULER
			{
				if (CmptD > 32767){CmptD = CmptD - 65535;}			// et dépasser 32767 = compter sous 0
				if (CmptD < -32767){CmptD = 0;}
			}

utilise un short , ça t'évitera ce genre de calcul !