Intéressant. Cela pourrait très bien être une faute dans le logiciel à virgule flottante. Les systèmes embarqués incluent souvent des virgules flottantes en option afin de réduire la taille du code.
Je ne suis pas sûr que ce soit le problème ici, même si votre première déclaration fonctionne.
Que se passe avec:
result = 0.005 - 0.001;
result = -result;
result = 0.002 - 0.001;
result = 0.002 - 0.002;
result = 0.002 - 0.003;
result = 0.001 - 0.002;
result = 0.001 - 0.003;
result = 0.001 - 0.004;
L'idée est de recueillir ici des informations utiles à ce qui pourrait être le cause, une chose commune à faire en médecine légale. Les résultats de ces calculs seront probablement utiles pour déterminer le problème réel.
En fonction de vos résultats dans les commentaires:
result = 0.005 - 0.001; // 0.004
result = -result; // 0.000
result = 0.002 - 0.001; // 0.001
result = 0.002 - 0.002; // 0.000
result = 0.002 - 0.003; // 0.000
result = 0.001 - 0.002; // 0.000
result = 0.001 - 0.003; // 0.000
result = 0.001 - 0.004; // 0.000
Il ressemble à votre bibliothèque de virgule flottante a une grave lacune. Deux autres questions:
- Comment allez-vous imprimer les résultats (nous montrer le code réel )?
- Quel microcontrôleur et environnement de développement utilisez-vous?
Il peut y avoir un problème avec la façon dont vous imprimez ou cela peut constituer une limitation de votre environnement. Ajit, je pense que vous allez vraiment devoir nous donner du code pour vous aider. Pas nécessairement votre vrai code (votre souci de libérer le vrai code est compris), juste quelques-uns qui démontrent le problème.
Basé sur certains de vos commentaires, à savoir:
Adriaan, le type de données « résultat » est de flotteur, qui est une représentation de 32 bits (simple). J'ai CAN comme interface système, et donc je multiplie le résultat par 1000 pour l'envoyer sur le bus CAN. S'il se trouve qu'il s'agit d'un nombre négatif, comme -0,003, j'attends FF FD dans le message CAN. Je n'ai pas de débogueur.
Je ne suis pas sûr de comprendre totalement, mais je vais essayer.
Vous avez un flotteur 32 bits, par exemple, -0,003 et vous multipliez par 1000 et le mettre dans un entier (0xFFFD est le 16 bits deux représentation de complément de -3).Alors qu'est-ce qui se passe lorsque vous exécutez quelque chose comme le code suivant:
int main(void) {
float w = -0.003;
int x = (int)(w * 1000);
int y = -3;
int z = -32768;
// Show us you code here for printing x, y and z.
return 0;
}
La raison pour laquelle je veux que vous tester un entier est qu'il peut avoir rien à voir avec flotteurs du tout. Il se peut que la valeur float soit parfaitement correcte, mais il y a un problème avec la façon dont vous l'imprimez (la méthode CAN).
Si "CAN" est une sorte d'interface série, il se peut qu'il y ait une restriction sur les octets que vous êtes autorisé à envoyer à travers. Je peux envisager un scénario où les octets élevés sont utilisés comme marqueurs de paquets, de sorte que FF peut effectivement terminer le message prématurément. C'est pourquoi je veux aussi que vous testiez -32768 (0x8000).
Il est difficile de croire que STMicroelectronics produirait un tel système d'exécution braindead qu'il ne pouvait pas gérer les flotteurs négatifs. Il me semble beaucoup plus probable que l'information soit corrompue ailleurs (par exemple, le processus d '«impression», quel qu'il soit).
Peut-être avez-vous un 'float non signé '. :) –