encoding sur 32 bit

Version imprimable

encoding sur 32 bit

Bonjour,

j'ai réalise une petite application qui me permet de récupère des données via un port série.
un exemple de type de données que je récupère:
987654321
039876532

je travaille sur 32 bit avec c#
quand j'affiche ces données dans une textBox je trouve les données en plus des symbole:

98765432103????
??4?64?F?????????????_

le code qui me permet de récupère les données:

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
 
 
public string value = string.Empty;
 
 private void serialPort2_DataReceived(object sender, SerialDataReceivedEventArgs e)
        {
 
             while (serialPort2.BytesToRead > 0)
            {
                //char[] buffer = new char[255]; // on crée un char de 255 caractere
                byte[] buffer =new byte[255];// nouveau
                int longueur_bytes_read = serialPort2.Read(buffer, 0, buffer.Length); //lecture du buffer jusqu'a sa longeur buffer.Length
                //tes characteres sont contenus dans buffer.
                //on remplit notre string value byte par byte par notre tableau de charactere buffer, le += fait que l'on écrase pas les données qui sont inserées, mais on les ajoutes.
 
                 for (int i = 0; i < longueur_bytes_read; i++)
                 {
                     string donne = Encoding.UTF8.GetString(buffer);             
                     value += donne[i];
 
                   // value = Encoding.UTF8.GetString(buffer);//nouveau
 
                    }
 
                 StatusLabel1.Text = "Transfert en cours...";                 
                }
 
            }
 
        private void button1_ecrir_Click(object sender, EventArgs e)
        {
 
            textBox1.AppendText(value + "\r\n");
        }

mais ça na rien changer. pouvez-vous m'aider???

09/06/2015, 10h15
theMonz31
la ligne :

Code:

string donne = Encoding.UTF8.GetString(buffer);

me semble qu'il faudrait plutôt écrire :
Code:

1 2 string donne = Encoding.UTF8.GetString(buffer[i]);
Comme ça, tu convertis chaque élement du buffer...

Dans ton code, tu récupères xx éléments dans un buffer[xx], donc, après, pour lire, on fait une boucle avec buffer[xx];

Maintenant, me semble que :
Code:

1 2 string s = Encoding.UTF8.GetString(buffer, 0, buffer.Length);
ferait le boulot sans faire une boucle...

bonjour,
merci beaucoup pour le retour.
j'ai adapter ton code mais j'ai une erreur : Error 1 The best overloaded method match for 'System.Text.Encoding.GetString(byte[])' has some invalid arguments.

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
 
public string value = string.Empty;
 private void serialPort2_DataReceived(object sender, SerialDataReceivedEventArgs e)
        {
 
 
             while (serialPort2.BytesToRead > 0)
            {
                byte[] buffer =new byte[255];// nouveau
                int longueur_bytes_read = serialPort2.Read(buffer, 0, buffer.Length); //lecture du buffer jusqu'a sa longeur buffer.Length
                //tes characteres sont contenus dans buffer.
                //on remplit notre string value byte par byte par notre tableau de charactere buffer, le += fait que l'on écrase pas les données qui sont inserées, mais on les ajoutes.
 
 
 
               for (int i = 0; i < longueur_bytes_read; i++)
                 {
                     value += Encoding.UTF8.GetString(buffer[i]);                                       
                }
                // StatusLabel1.Text = "Transfert en cours...";                 
                }
 
            }
 
        private void button1_ecrir_Click(object sender, EventArgs e)
        {
           // textBox1.SelectedText = string.Empty;
            textBox1.AppendText(value.ToString() + "\r\n");
        }

quand j'ai met juste cette ligne sans la boucle:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
public string value = string.Empty;
 private void serialPort2_DataReceived(object sender, SerialDataReceivedEventArgs e)
        {
 
 
             while (serialPort2.BytesToRead > 0)
            {
                byte[] buffer =new byte[255];// nouveau
                int longueur_bytes_read = serialPort2.Read(buffer, 0, buffer.Length); //lecture du buffer jusqu'a sa longeur buffer.Length
                //tes characteres sont contenus dans buffer.
                //on remplit notre string value byte par byte par notre tableau de charactere buffer, le += fait que l'on écrase pas les données qui sont inserées, mais on les ajoutes.
 
                value = Encoding.UTF8.GetString(buffer, 0, buffer.Length);
                }
 
            }
 
        private void button1_ecrir_Click(object sender, EventArgs e)
        {
           // textBox1.SelectedText = string.Empty;
            textBox1.AppendText(value.ToString() + "\r\n");

j'ai en affichage une seule valeur égale à : 0

09/06/2015, 10h49
theMonz31

bah faut faire comme tout le monde, débugguer :)

Regarder la taille du tableau, etc...

Essayer du code (en dehors de ta boucle, pour valider la conversion par exemple), etc...
09/06/2015, 11h58
tintine

merci beaucoup pour l'aide.

cette application je l'es faite sur un pc Windows 8 - 64 bits qui fonctionne parfaitement bien.

ensuit j'ai fait l’exécutable, afin de passe à autre pc (Windows XP - 32-bits ).
pour passer a 32 bit, j'ai changé donc dans les propriété de l'application, mets en " Release " et en "x86" .

quand je l’exécute monAppli.exe sur le 32 bit je reçois les données et quand je les affiche dans la textBox, il sont pas afficher correctement (des données + des symbole)

donc je me suis dit ça peut être au niveau du codage, mais ça n'a rien changer.

J'ai beaucoup réessayer/vérifier mais je n'y arrive pas.
10/06/2015, 07h59
tintine

bonjour,

Je cherche a savoir comment convertir un ASCII en string a partir d'un en UNICODE ?

:calim2::calim2:
10/06/2015, 08h47
DonQuiche

A priori je dirais que tu reçois des données supplémentaires au-delà de la chaîne et que tu devras rechercher manuellement un '\0' marquant la fin de la chaîne. Avant tout il faudrait quand même vérifier la doc du périphérique.

Cela dit tu fais une chose très dangereuse dans ce code, même si ça fonctionnera tant que tu ne reçois que des caractères ASCII (< 128) : tu assimiles octet (byte) et caractère en utilisant i (une position en octets) pour indexer une chaîne (une position en caractères). Or en utf-8 un caractère peut mesurer de un à quatre octets.

La bonne façon de faire est de d'abord récolter tous les octets en les ajoutant à une liste. Puis, une fois la boucle principale finie (une fois tous les octets lus depuis le port série et stockés dans la liste), tu transformes cette liste en une chaîne via Encoding.ReadString.

Enfin, gaffe : tu as pris Utf8 qui fonctionne pour ASCII mais es-tu sûr que tes données sont encodées en Utf-8 et pas en un ANSI-Fr ou autre ?

1 pièce(s) jointe(s)

j'ai fait ce bout de code et ça na rien changer:

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
 
public string value = string.Empty;
 
private void serialPort2_DataReceived(object sender, SerialDataReceivedEventArgs e)
        {
            serialPort2.Write("\u000D");// lance la tach envoiFil
 
             while (serialPort2.BytesToRead > 0)
            {
               char[] buffer = new char[255]; // on crée un char de 255 caractere
               //byte[] buffer =new byte[255];// nouveau
 
                int longueur_bytes_read = serialPort2.Read(buffer, 0, buffer.Length); //lecture du buffer jusqu'a sa longeur buffer.Length               
                //tes caractères sont contenus dans buffer.
                //on remplit notre string value byte par byte par notre tableau de charactere buffer, le += fait que l'on écrase pas les données qui sont insérées, mais on les ajoutes.            
 
                 for (int i = 0; i < longueur_bytes_read; i++)
                 {                                 
                     value +=buffer[i]; 
                     byte[] bytes = Encoding.Default.GetBytes(value);
                     value = Encoding.UTF8.GetString(bytes);                                                       
                }
 
                 StatusLabel1.Text = "Transfert en cours...";                 
                }
 
            }
 
        private void button1_ecrir_Click(object sender, EventArgs e)
        {
            textBox1.AppendText(value.ToString() + "\r\n");            
        }

voila un bout de données que je récupere sur 32 bit : Pièce jointe 180184

10/06/2015, 10h58
DonQuiche

Apparemment tu n'as pas compris ce que j'ai voulu t'expliquer, je reprends donc.

a) Dans ta boucle "while (serialPort2.BytesToRead > 0)" tu ne dois pas, à aucun moment, créer de chaîne. Contente-toi de lire des octets et de les stocker dans une liste de type List<byte>. Pas d'encoding, ni de string, ni de value, ni quoi que ce soit de ce genre.

b) Si un octet vaut 0, tu ne l'ajoutes pas et tu arrêtes de lire les données (ou, si tu es obligé de vider le tampon, tu n'ajoutes pas les données restantes à la liste).

c) Une fois la boucle finie tu convertis la liste entière d'octets en chaîne.

merci beaucoup #DonQuiche pour ton retour.

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
 
 
 private void serialPort2_DataReceived(object sender, SerialDataReceivedEventArgs e)
        {
   int bytes = serialPort2.BytesToRead;
            while (bytes > 0)
            {
                byte[] buffer = new byte[bytes];
                serialPort2.Read(buffer, 0, bytes);
                List<byte> myBytesList = buffer.ToList();
                value = System.Text.Encoding.UTF8.GetString(myBytesList.ToArray());
 
            }
    }
 
 
 
        private void button1_ecrir_Click(object sender, EventArgs e)
        {
            //textBox1.SelectedText = string.Empty;
            textBox1.AppendText(value + "\r\n");
 
 
        }

11/06/2015, 14h20
tintine

J'ai beaucoup réessayer/vérifier mais je n'y arrive pas.
pouvez-vous m'aide??????

Je te propose ça :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
        void serialPort2_DataReceived(object sender, SerialDataReceivedEventArgs e)
        {
            var data = ReadAllBytes();
            value = System.Text.Encoding.UTF8.GetString(data);
        }
 
        byte[] ReadAllBytes()
        {
            var result = new List<byte>();
            var buffer = new byte[serialPort2.BytesToRead];
 
            while (true)
            {
                var bytes = serialPort2.Read(buffer, 0, buffer.Length);
                if (bytes == 0) return result.ToArray();
 
                for (int i = 0; i < bytes; ++i)
                {
                    if (buffer[i] == 0) return result.ToArray();    // Ligne à commenter ou non.
                    result.Add(buffer[i]);
                }
            }
        }

Et tu essaieras de commenter ou non la ligne indiquée dans la source pour voir ce que ça donne. Tout dépend du format de ton entrée. Et si avec ce code il n'y a que la première ligne qui est correcte, alors c'est que tu as des données entre tes chaînes de caractère et il te faudra étudier le protocole de ton périphérique en détail pour savoir combien d'octets tu dois sauter.

16/06/2015, 13h07
tintine

Bonjour,

j'ai adapté ton code à mon application mais ça n'a rien changer.

j'ai constaté le problème dans le port série, vu que sur ma machine (64 bit) j’utilise un adaptateur (usb- port série d’où j'ai installé son drive de 64 bit) et sur l'autre machine ( 32 bit) j'utilise directement le port série.

y a t il un moyen pour pour régler ça?
19/06/2015, 13h02
tintine

Bonjour,

le souci c'étais dans le port du pc :roll::roll:

merci