Discussion :

[davidif]

Bonjour,

étant un léger habitué de delphi, la source de programmation qui fonctionne pour récupérer une valeur sur mon port USB que j'ai pu trouvé est compilé sous Visual C++ et afin de l'utiliser j'essai de comprendre comment il fonctionne globalement.

J'ai pu repérer a quel moment la valeur est récupérer et afficher dans une textbox, seulement mon problème est qu'il m'affiche ma valeur en ASCII et non comme je le souhaiterai en decimal.

Si je ne trompe pas la fonction qui récupère ma donnée est celle-ci

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
		private: System::Void serialPort1_DataReceived(System::Object^  sender, System::IO::Ports::SerialDataReceivedEventArgs^  e) 
		{
			//The ReadExisting() function will read all of the data that
			//  is currently available in the COM port buffer.  In this 
			//  example we are sending all of the available COM port data
			//  to the SetText() function.
			//
			//  NOTE: the <SerialPort>_DataReceived() function is launched
			//  in a seperate thread from the rest of the application.  A
			//  delegate function is required in order to properly access
			//  any managed objects inside of the other thread.  Since we
			//  will be writing to a textBox (a managed object) the delegate
			//  function is required.  Please see the SetText() function for 
			//  more information about delegate functions and how to use them.
			try
			{
				SetText(serialPort1->ReadExisting());
			}
			catch(...)
			{
			}
		}

Puis je l'affiche ici :

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
		private: void SetText(String^ text)
		{
			//InvokeRequired required compares the thread ID of the
			//  calling thread to the thread ID of the creating thread.
			//  If these threads are different, it returns true.  We can
			//  use this attribute to determine if we can append text
			//  directly to the textbox or if we must launch an a delegate
			//  function instance to write to the textbox.
 
			//if (this->txtDataReceived->InvokeRequired)
			if (this->txtDataReceived1->InvokeRequired) //Laurent
			{
				//InvokeRequired returned TRUE meaning that this function
				//  was called from a thread different than the current
				//  thread.  We must launch a deleage function.
 
				//Create an instance of the SetTextCallback delegate and
				//  assign the delegate function to be this function.  This
				//  effectively causes this same SetText() function to be
				//  called within the main thread instead of the second
				//  thread.
				SetTextCallback^ d = gcnew SetTextCallback(this,&VCCDC::Form1::SetText);
 
				//Invoke the new delegate sending the same text to the
				//  delegate that was passed into this function from the
				//  other thread.
				this->Invoke(d,gcnew String(text));
			}
			else
			{
				//If this function was called from the same thread that 
				//  holds the required objects then just add the text.
 
				txtDataReceived1->AppendText(text); // laurent
				//txtDataReceived->AppendText(text); 
			}
		}

s'il vous plait dîtes moi comment ou avec quelle fonction je peux afficher ma valeur en décimal ?

Merci

[davidif]

Si quelqu'un pourrai me renseigner à ce sujet, je n'arrive toujours pas à récupérer une valeurs en decimal et non en ascii

[davidif]

Je n'avance pas du tout, et stagne a fond, mes fichiers sont ici, si un pro de visual studio pouvait m'extirper de ce problème

https://www.dropbox.com/sh/nfgbsuhj5vdeh8m/DUXv_yMsB5

[davidif]

s'il vous plait, là c'est le surplace depuis 1 semaine, quelqu'un pourrais me dire quoi faire, j'essai plein de truc qui pour l'instant ne fonctionne pas.

En fait j'ai une application qui communique bien sur mon bus USB compilé sous visual C++ (je ne connais pas cette IDE)mais que j'aimerai modifié pour mon besoin alors qu'étant plus familliarisé à delphi, celui-ci je n'arrive pas à ajouter le composant tcomport pour commencer un début de code.

[Médinoc]

Bonjour,
Je ne comprends pas exactement ton problème:

• Quelle donnée cherches-tu à recevoir?
• Sous quel format? Binaire brut, chaîne de caractères (si oui, quelle format de chaîne et quel encodage?)
• Sous quel format cherches-tu à l'afficher?

[davidif]

En faite comme tu peux le constater sur le jpeg, le form que j'ai fais résume l'état de fonctionnement de mon pic, je souhaite afficher les valeurs envoyé par celui-ci et les afficher dans les textbox correspondant.

C'est valeurs sont tranmises en hexa sur mon bus, et je souhaite les traiter pour d'une part les identifier puis les afficher dans la cases correspondantes en décimale pour l'instant ou en hexa puisqu'il s'agit de données ADC et pwm, mais pour le moment on va ce limite par décimal

j'ai cru voir que par exemple la fonction AppendText() encode les données en UTF-8 assimilé a de l'ascii, le problème viendrait de là ?

[Médinoc]

Donc, tu reçois ton nombre en tant que données brutes, mais tu utilises ReadExisting() qui lit du texte...

Tu dois utiliser une autre fonction (comme Read() tout court avec des byte[]) puis convertir ces bytes en un seul entier, avec une fonction de ce genre:

Code C++/CLI :

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
int IntFromBytesLittleEndian(array<System::Byte>^ arr, int offset)
{
	int ret = 0, by;
	by=arr[offset++];
	ret |= (by);
	by=arr[offset++];
	ret |= (by << 8);
	by=arr[offset++];
	ret |= (by << 16);
	by=arr[offset++];
	ret |= (by << 24);
};
 
int IntFromBytesBigEndian(array<System::Byte>^ arr, int offset)
{
	int ret = 0, by;
	by=arr[offset++];
	ret |= (by << 24);
	by=arr[offset++];
	ret |= (by << 16);
	by=arr[offset++];
	ret |= (by << 8);
	by=arr[offset++];
	ret |= (by);
};

[davidif]

Merci Medinoc pour l'info, je comprend ce que tu me dis de faire, seulement ma méconnaissance de l'environnement ne m'amène pas encore à un résulta satisfaisant pour le moment;

En fait, j'ai commencé par chercher la fonction read() tout court :

serialPort1->Read(); seulement là j'ai cette erreur

Erreur 1 error C2661: 'System::IO:orts::SerialPort::Read'*: aucune fonction surchargée ne nécessite 0 arguments

Ensuite j'ai fait un

serialPort1->Readbyte(); et là j'ai

Erreur 1 error C2039: 'Readbyte'*: n'est pas membre de 'System::IO:orts::SerialPort'

Ensuite vu que la fonction de conversion que tu m'a envoyé demande un tableau comme argument j'ai fait ça

CHAR data[4];
int nbr_octet, val;

nbr_octet=Read(data[4], 0, 4);

Erreur 1 error C3861: 'Read'*: identificateur introuvable

Ensuite pour convertir je suppose que je dois faire comme ça

val=IntFromBytesLittleEndian(data,0);

ce qui est dingue,c'est que ces fonctions sont bien existante puisque je les voient proposé seulement il ne les reconnait pas une fois rédigé ??

tout ces essai sont mise dans
private: System::Void serialPort1_DataReceived(System::Object^ sender, System::IO:orts::SerialDataReceivedEventArgs^ e)

[davidif]

cette fonction permet bien de récupérer les données et les met dans un tableau

System:ata::SqlTypes::SqlFileStream::Read(array<unsigned char>^, int, int)

public : virtual int Read(array<unsigned char>^ buffer, int offset, int count) override
Membre de System:ata::SqlTypes::SqlFileStream

Résumé*:
Lit une séquence d'octets dans le flux actuel et avance la position dans le flux du nombre d'octets lus.

Paramètres*:
buffer: Tableau d'octets.Lorsque cette méthode est retournée, la mémoire tampon contient le tableau d'octets spécifié dont les valeurs comprises entre l'offset et (offset + count - 1) sont remplacées par les octets lus dans la source en cours.
offset: L'offset d'octet de base zéro dans la mémoire tampon à partir duquel commencer l'enregistrement des données lues dans le flux actuel.
count: Nombre maximal d'octets à lire à partir du flux actuel.

Valeurs de retour*:
Nombre total d'octets lus dans la mémoire tampon.Cela peut être inférieur au nombre d'octets demandé si ce nombre n'est pas actuellement disponible ou égal à zéro (0) si la fin du flux a été atteinte.

Exceptions*:
System::NotSupportedException: L'objet ne prend pas en charge la lecture de données.

a quel moment n'ai- je pas compris la suptilitée

[Médinoc]

Essaie ceci:

Code C++/CLI :

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

1
2
3
4
5
6
7
8
9
10
11
//Un tableau managé de quatre bytes
array<System::Byte>^ buf = gcnew array<System::Byte>(4);
 
//On lit les quatre bytes
serialPort1->Read(buf, 0, 4);
 
//On les convertit en int
int valeur = IntFromBytesBigEndian(buf, 0);
 
//Et on affiche en hexadécimal
SetText(valeur.ToString("X8"));

[davidif]

j'ai écrit ça ici :

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
		private: System::Void serialPort1_DataReceived(System::Object^  sender, System::IO::Ports::SerialDataReceivedEventArgs^  e) 
		{
			//The ReadExisting() function will read all of the data that
			//  is currently available in the COM port buffer.  In this 
			//  example we are sending all of the available COM port data
			//  to the SetText() function.
			//
			//  NOTE: the <SerialPort>_DataReceived() function is launched
			//  in a seperate thread from the rest of the application.  A
			//  delegate function is required in order to properly access
			//  any managed objects inside of the other thread.  Since we
			//  will be writing to a textBox (a managed object) the delegate
			//  function is required.  Please see the SetText() function for 
			//  more information about delegate functions and how to use them.
			try
			{
 
				//serialPort1->Read(data[4], 0, 4);
 
				//textBox6->AppendText();
				//nbr_octet=Read(data[4], 0, 4);
				//val=IntFromBytesLittleEndian(data,4);
				//affiche(serialPort1->ReadExisting());
 
 
				//Un tableau managé de quatre bytes
				array<System::Byte>^ buf = gcnew array<System::Byte>(4);
 
				//On lit les quatre bytes
				serialPort1->Read(buf, 0, 4);
 
				//On les convertit en int
				int valeur = IntFromBytesBigEndian(buf, 0);
 
				//Et on affiche en hexadécimal
				SetText(valeur.ToString("X8"));
 
 
			}
			catch(...)
			{
			}
		}

"IntFromBytesBigEndian" est indiqué comme erreur

Erreur 1 error C3861: 'IntFromBytesBigEndian'*: identificateur introuvable

j'ai déclaré cette fonction en haute avec les variables

Code :

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

1
2
3
	char unsigned data[4], data_char;
	int nbr_octet, val;
	int IntFromBytesLittleEndian(array<System::Byte>^ arr, int offset);

[davidif]

Merci Médinoc, enfin je peux avancé un peu , ça y est ça fonctionne, je sors bien une valeur hexa.

En fait, la dernière erreur que j'avais était causé par le fait que dans la fonction de convertion

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
	 int IntFromBytesLittleEndian(array<System::Byte>^ arr, int offset)
				 {
					 int ret = 0, by;
 
					 by = arr[offset++];
					 ret |= (by);
					 by = arr[offset++];
					 ret |= (by << 8);
					 by = arr[offset++];
					 ret |= (by << 16);
					 by = arr[offset++];
					 ret |= (by << 24);
 
 
 
 
				 };

Erreur 1 error C4716: 'VCCDC::Form1::IntFromBytesLittleEndian' : doit retourner une valeur

J'ai donc rajouté le "return ret;" a la fin de la fonction et impec !!

Bon ! une étape de franchi ! à la prochaine maintenant encore merci beaucoup
ça fait du bien d'avoir quelque chose qui fonctionne

[davidif]

pour comprendre, pourquoi mets tu "x8"

SetText(valeur.ToString("X8")); si je souhaite maintenant afficher en décimal je peux donc utiliser valeur.ToDecimal ?

[Médinoc]

ToDecimal() retourne un System::Decimal; ce qu'il te faut, c'est appeler ToString() sans argument, ou avec l'argument "D".
Les différents formats sont accessibles sur cette page: Standard numeric format strings

"X8" signifie "Hexadécimal en majuscules sur huit chiffres"

[davidif]

Super Merci

[davidif]

Juste une petit précision, je balance des données en permanence sur mon bus USB et avec ce programme j'affiche donc ces mêmes données qui varie en fonction de la tension envoyée en entrée ADC de mon microproc.

Il ce trouve qu'il y a une latence de 3 à 4s a partir du moment ou je fais varié cette tension et la variation à l'écran.

En regardant les caractères affiché à l'origine en ASCII, celle-ci réagissent bien au changement, seulement quand je passe par la récupération dans un tableau puis conversion comme proposé dernièrement j'ai à nouveau cette latence ?

Est-ce normal par rapport au code qui demanderai plus de temps de traitement