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 !

[ternel]

Euh, non.
La taille de short n'est pas limité par la norme, et les "overflow" sont des "undefined behaviours".

[fred7]

Effectivement un short de soulage de ces tests.
Reste plus que le problème de base

[Matt_Houston]

Pas de raison particulière non.

Alors utilise plutôt un type adapté : tiens t'en à celui que te renvoie Qcntr_Read.

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.

Un invariant est une contrainte que tu fais respecter à une variable et aux transformations qu'elle subit. Comme tu cherches à appliquer cet invariant à plusieurs endroits et à plusieurs propriétés (CmptD et CmptG), tu es amené à dupliquer du code : c'est signe qu'il faut écrire une fonction.

Effectivement un short de soulage de ces tests.

short, non. unsigned short, peut-être. uint16_t, certainement. As-tu lu tous les messages du fil ?

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

[...]

Reste plus que le problème de base

Justement : quel est-il au final ? Procédons par étape, et résolvons les problèmes dans l'ordre où ils se présentent. La première partie de ta fonction est erronée, commençons par là.

[Kannagi]

Euh, non.
La taille de short n'est pas limité par la norme, et les "overflow" sont des "undefined behaviours".

Exact mais j'avais bien la flemme de lui balancer la norme et de lui expliquer en détail , mais il y'a de grande chance que son short fasse 2 octet sauf s'il code sur une machine assez particulière qui supporte pas les 2 octets (parce que de mon point de vue si la norme ne le précise pas clairement c'est bien pour des raisons hardware avant tout).

[fred7]

Oui j'ai tout lu (je ne suis pas un sale gosse hein, des gens prennent la peine de me répondre donc je lis ).

Pour clarifier la chose ma fonction Qcntr_Read(); me renvoie une valeur de type unsigned short du coup j'ai suivi le conseil de Kannagi et j'ai utiliser un short pour CmptD afin de me passer de ma structure conditionnelle.

Et effectivement après essai ça marche et ça donne donc ceci:

Code :

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

1
2
3
4
5
6
7
 
short CmptD;
 
void Comptage(void)
{
CmptD = Qcntr_Read(QcntrD);
}

A ce stade j'ose imaginer que cette partie de code ne comporte plus d'erreurs...

[ternel]

Ça dépend du point de vue.
Pour la norme, son comportement est indéfini (non spécifié par la norme ni le compilateur). Donc, il peut marcher ce matin, et pas ce soir.

[fred7]

Ça dépend du point de vue.
Pour la norme, son comportement est indéfini (non spécifié par la norme ni le compilateur). Donc, il peut marcher ce matin, et pas ce soir.

Comme ça c'est mieux ?

Code :

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

1
2
3
4
5
6
7
 
int16_t CmptD;
 
void Comptage(void)
{
CmptD = Qcntr_Read(QcntrD);
}

[Matt_Houston]

Mais où est passé le reste du code de la fonction ?

Si ton API te renvoie un entier non signé (unsigned short), ce n'est nullement un hasard. Pour quelle raison places-tu la valeur de retour dans un entier signé (short, int16_t..) ? Ce genre de décision qui peut avoir des conséquences.. « palpables » doit toujours se justifier.

Pour résumer, tu as deux choix :

• soit tu fais déborder un entier non signé - parce que sinon, c'est un comportement indéfini comme nous l'avons précisé - avec une petite manip pour obtenir un entier signé sur un intervalle de valeurs « décalé » (centré sur zéro) ;
• soit tu réalises explicitement des transformations comme tu l'as proposé initialement mais sur un entier de capacité supérieure à celui que tu reçois (si sizeof(unsigned short) == 2, alors int_least32_t par exemple), si un tel type existe.