Probléme pour convertir decimal en hexa

Version imprimable

Salut,

alors voila je rentre une valeur en decimale et je voudrai la recupérer en hexa alors j'ai d'abord fait un petit programme test mais qui ne marche pas et la je voit pas pourquoi :?
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 #include <stdio.h> #include <conio.h> #include <iostream> #include <iomanip> #include <sstream> void main() { float Write; std::ostringstream str; std::cout<<"\nSaisir la valeur: "; std::cin>>Write; Write=Write*10; str<<std::hex<<Write; std::cout<<"\nstr="<<str.str(); getch(); }
Si je rentre 32.1 par exemple il m'affiche str=321 :(

A terme je voudrai que cette valeur en hexa sois stocker sur 2 octet pour les envoyer dans une trame, c'est possible avec un ostringstream?

19/05/2009, 10h59
Lucien63

Oui mais c'est un float que tu prend en entrée, alors c'est peut-être normal que ça marche pas.

a oui ok, je vient d'essayer avec un int il me convertie bien mais je veux rentrer des chiffres à virgule...

Edit: c'est bon j'y arrive en faisant
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 void main() { float Write; int write; std::ostringstream str; std::cout<<"\nSaisir la valeur: "; std::cin>>Write; write=Write*10; str<<std::hex<<write; std::cout<<"\nstr="<<str.str(); getch(); }
donc si je rentre 32.1 j'obtient bien 140
mais maintenant je voudrai stocker 01 dans Tab[0] et 40 dans Tab[1], c'est possible?

19/05/2009, 11h12
Médinoc

On ne voit pas Tab et on ne sait pas d'où viennent ces valeurs.
Code?
19/05/2009, 11h21
vtk37
pour l'instant Tab n'existe pas

Je m'explique plus clairement:

Dans ma console on me demande de saisir une valeur,
si je rentre 32.1
cela m'affiche "str=140" donc la valeur hexa de 321

maintenant j'ai besoin de cette valeur hexa pour quelle fasse partie d'un trame
qui ressemblera à sa: 06 28 02 01 40
les 2 derniers octet correspondant à la valeur hexa de la consigne rentrée en decimale ;)

donc je voudrai savoir comment récupérer ce 140 en 2 partie 01 et 40 que je stockerai dans un tableau par exemple pour faire sa:
Code:

1 2 3 4 5 6 7 trame_a_envoyer[0]=0x06; trame_a_envoyer[1]=0x28; trame_a_envoyer[2]=0x02; trame_a_envoyer[3]=Tab[0]; // avec Tab[0]=01 trame_a_envoyer[4]=Tab[1]; // avec Tab[1]=40 trame_a_envoyer[5]='\0'
voila, je sais pas comment manipuler ostringstream str pour recuperer ce que je souhaite ...
19/05/2009, 11h47
ptyxs

Je suggèrerais que tu fournisses les déclarations de trame_a_envoyer et de Tab. On y verrait un peu plus clair.

mais pour l'instant il ne sont pas declarer puisque je sais pas comment les declarer puisque je ne sais même pas si c'est possible de récupérer la valeur qui m'intéresse... est-ce que vous avez compris ce que je veux faire?

a terme le programme pourrai ressembler à sa:

Code:

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
#include <stdio.h>
#include <conio.h>
#include <iostream>
#include <iomanip>
#include <sstream>
 
void main()
{
 
	float Write;
        int write;
        char trame_a_envoyer[5];
        char Tab[1];
 
	std::ostringstream str;
	std::cout<<"\nSaisir la valeur: ";
	std::cin>>Write;
	write=Write*10;
 
	str<<std::hex<<write;
	std::cout<<"\nstr="<<str.str();
 
        //la partie que je ne sais pas comment faire
        Tab[0]= // le debut de str 
        Tab[1]=// la fin de str
 
        trame_a_envoyer[0]=0x06;
        trame_a_envoyer[1]=0x28;
        trame_a_envoyer[2]=0x02;
        trame_a_envoyer[3]=Tab[0]; // avec Tab[0]=01 si je saisie 32.1
        trame_a_envoyer[4]=Tab[1]; // avec Tab[1]=40
        trame_a_envoyer[5]='\0'
 
 
        sendframe(trame_a_envoyer);
 
 
	system("pause");
 
 
 
}

comme sa n'a pas l'air d'etre trés clair pour tout le monde je vais mettre le programme complet dans lequel sera utilisé cette conversion:

Code:

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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
#include <stdio.h>
#include <conio.h>
#include <iostream>
#include <iomanip>
#include <sstream>
#include <windows.h>
#include <string.h>
#include <boost/assign/std/vector.hpp>
#include <vector>
 
#define READ_VAR 0x03
#define WRITE_VAR 0x06
 
 
int init_serie();
//int ReceiveTrame(char *ChaineRecue);
int SendTrame(char ChaineEnvoie[50]);
int Receiveframe(std::vector<unsigned char> &buf_reception);
HANDLE hSerie;
 
/**************Programme principale**************/
void main (void)
{
 
	std::vector<unsigned char> buffer_rec;
 
	char chaineEnvoie[50];
	char Presence[2],Ecrire[2];
	int TimeoutRead = 100; // timeout en ms
	COMMTIMEOUTS tTimeout;
	float temperature,humidite;
	float Tair,Tcut,HR,Consigne,Write;
	int i,Select,Envoyer,CheckInit,Carte(0),Retour(0);
	int touche=-1; 
 
 
 
	/***Ouverture du port de communication***/
	hSerie=CreateFile(TEXT("COM1"),					//Nom du port
					  GENERIC_READ|GENERIC_WRITE,	//permet l'ecriture et la lecture sur le port
					  0,							//Mode de partage
					  NULL,							//Option de sécurité par défaut
					  OPEN_EXISTING,				
					  0,							//NULL=synchrone, sinon asynchrone
					  NULL);
 
	std::cout<<"Connection en cours...\n";
	CheckInit=init_serie(); // initialise le port serie
 
 
	/***configurer le timeout***/
	tTimeout.ReadIntervalTimeout = MAXWORD;
	tTimeout.ReadTotalTimeoutMultiplier = 0;
	tTimeout.ReadTotalTimeoutConstant = TimeoutRead; // pas de time out = 0
	tTimeout.WriteTotalTimeoutMultiplier = 0;
	tTimeout.WriteTotalTimeoutConstant = 0;
	SetCommTimeouts(hSerie,&tTimeout);
 
	/**verifier la présence de la carte**/
	Presence[0]=0xAAu;
	Presence[1]='\0';
	Envoyer=SendTrame(Presence);
	Retour=Receiveframe(buffer_rec);
 
	if(Retour==1)
	{
		if(buffer_rec[0]==0xaa)
		{
			std::cout<<"\n--Carte presente--\n\n";
			Carte=1;
		}
	}
	else
	{
		std::cout<<"\nCarte absente\n\n";
		Carte=0;
	}
	system("pause");
	/************************************/
 
	if((Carte==1)&(Retour==1))
	{
 
 
		std::cout<<"\nChoix: \n\t-[1]Lecture  \n\t-[2] Ecriture ";
		std::cout<<"\nSaisir un chiffre puis appuyer sur entree ";
		std::cin>>Select;
 
		switch(Select) 
		{
		case 1:
			//blablabla...
			}
			break;
 
		case 2: 
			std::ostringstream str;
			/*std::cout<<"\nSaisir la nouvelle consigne: ";
			std::cin>>Write;
			int write=Write*10;
 
			str<<std::hex<<write;
			std::cout<<"\nstr="<<str.str();*/
 
                         //ces valeurs doivent changer en fonction de la consigne saisie elle sont fixe pour les test
			Ecrire[0]=0x01;
			Ecrire[1]=0x45;
 
 
			chaineEnvoie[0]=WRITE_VAR;
			chaineEnvoie[1]=0x28;
			chaineEnvoie[2]=0x02;
			chaineEnvoie[3]=Ecrire[0];
			chaineEnvoie[4]=Ecrire[1];
			chaineEnvoie[5]='\0';
 
			for(i=0;i<=4;i++)
				printf(" %02X",chaineEnvoie[i]);
 
			Envoyer=SendTrame(chaineEnvoie);	
				if(Envoyer==1)
				{
					int a=Receiveframe(buffer_rec);
					if (a==1)
						printf("\nEcriture correcte",HR);					
				}
				system("pause");
			break;
		}
 
	}
	CloseHandle(hSerie); // ferme le port
 
}

Code:

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
/**************Réception d'une trame**************/
int Receiveframe(std::vector<unsigned char> &buf_reception)
{
	const  size_t taille_buffer_reception(200);
	unsigned long nBytesRead(0);
	std::vector<unsigned char> buffer;
 
	buf_reception.resize(0);
	buffer.resize(taille_buffer_reception);
 
	BOOL bResult = ReadFile(hSerie,&buffer[0],taille_buffer_reception-1,&nBytesRead,NULL);
 
	if(nBytesRead>0)
	{
      buffer.resize(nBytesRead);
      buf_reception.resize(nBytesRead);
 
      // recopie des donnees :
      std::copy(buffer.begin(),buffer.end(),buf_reception.begin());
 
      /*// affichage des donnees recues :
      std::copy(
         buf_reception.begin(),
         buf_reception.end(),
         std::ostream_iterator<unsigned int>(std::cout<<std::hex," ")
      );
      std::cout<<std::endl;
      std::cout<<"\nNombre d'octets recus : "<<nBytesRead<<std::endl;*/
	}
   else{
		printf("\n--Aucune donn%ces re%cues--",130,135);
		return (0);
   }  
	return(1);
}

Code:

1
2
3
4
5
6
7
8
9
10
/**************Evoie d'une trame**************/
int SendTrame(char ChaineEnvoie[50])
{
	int NbOctet;
	unsigned long nBytesWrite;
 
	NbOctet = strlen(ChaineEnvoie);  //compte le nombre d'octet à envoyer
	WriteFile(hSerie,ChaineEnvoie,NbOctet,&nBytesWrite,NULL);	
	return(1);
}