Lire port série C# et convertir en texte

**Narizuke** · 24/04/2012, 10h01

Bonjour à tous,

Je viens vous solliciter parce que je rencontre un petit soucis. Je suis en train de développer une petite application qui me permet de lire les données d'un chronomètre. J'ai réussi à faire la lecture des données, mais comme c'est la première fois que je fais ça, j'aurais voulu savoir comment traduire en format texte ce qui ressort du chrono, c'est-à-dire comment obtenir le temps indiquer sur le chronomètre. Pour l'instant, je récupère mes données en héxa. Mais je bloque sur la conversion en chaîne.

Je vous mets le code que j'utilise pour la lecture du port série.

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
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
 
using System;
using System.Linq;
using System.Data;
using System.Text;
using System.Drawing;
using System.IO.Ports;
using System.Windows.Forms;
using System.ComponentModel;
using System.Collections.Generic;
 
using System.Threading;
using System.IO;
 
namespace WindowsFormsApplication1
{
    public partial class Form1 : Form
    {
        private SerialPort sp = new SerialPort();
        public enum LogMsgType { Incoming, Outgoing, Normal, Warning, Error };
        private Color[] LogMsgTypeColor = { Color.Blue, Color.Green, Color.Black, Color.Orange, Color.Red };
 
        public Form1()
        {
            InitializeComponent();
 
            sp.BaudRate = 9600;
            sp.Parity = Parity.None;
            sp.StopBits = StopBits.One;
            sp.DataBits = 8;
            sp.Handshake = Handshake.None;
            sp.DataReceived += new SerialDataReceivedEventHandler(port_DataReceived);
        }
 
        private void button1_Click(object sender, EventArgs e)
        {
            bool erreur = false;
 
            // Si le port est ouvert, il faut le fermer
            if (sp.IsOpen) sp.Close();
            else
            {
                // Réglage paramètre du port
                sp.PortName = cmbPortName.Text;
 
                try
                {
                    // Ouvrir le port
                    sp.Open();
                }
                catch (UnauthorizedAccessException) { erreur = true; }
                catch (IOException) { erreur = true; }
                catch (ArgumentException) { erreur = true; }
 
                if (erreur)
                    MessageBox.Show("Impossible d'ouvrir le port COM. Très probablement, il est déjà en cours d'utilisation, a été supprimé, ou n'est pas disponible.", "COM Port indisponible", MessageBoxButtons.OK, MessageBoxIcon.Stop);
                else
                    MessageBox.Show("Connexion réussi","Port disponible");
            }
        }
 
        // Connexion à la fenêtre du terminal
        private void Log(LogMsgType msgtype, string msg)
        {
            rtfTerminal.Invoke(new EventHandler(delegate
            {
                rtfTerminal.SelectedText = string.Empty;
                rtfTerminal.SelectionFont = new Font(rtfTerminal.SelectionFont, FontStyle.Bold);
                rtfTerminal.SelectionColor = LogMsgTypeColor[(int)msgtype];
                rtfTerminal.AppendText(msg);
                rtfTerminal.ScrollToCaret();
            }));
        }
 
        //Convertit un tableau d'octets en une chaîne formatée de chiffres hexadécimaux.
        private string ByteArrayToHexString(byte[] data)
        {
            StringBuilder sb = new StringBuilder(data.Length * 3);
            foreach (byte b in data)
                sb.Append(Convert.ToString(b, 16).PadLeft(2, '0').PadRight(3, ' '));
            return sb.ToString().ToUpper();
        }
 
 
        private void port_DataReceived(object sender, SerialDataReceivedEventArgs e)
        {
            // Si le port est ouvert, le fermer
            if (!sp.IsOpen) return;
 
            // Obtenir le nombre d'octets en attente dans le tampon du port
            int bytes = sp.BytesToRead;
 
            // Créez une zone tampon (tableau d'octets) pour stocker les données entrantes
            byte[] buffer = new byte[bytes];
 
            // Lire les données du port et de le stocker dans la mémoire tampon
            sp.Read(buffer, 0, bytes);
 
            // Montrer à l'utilisateur les données entrantes dans un format hexadécimal
            Log(LogMsgType.Incoming, ByteArrayToHexString(buffer));
 
        }
    }
}

Je vous remercie d'avance.

**synolog** · 24/04/2012, 10h15

Bonjour,

Pour convertir un hexa en string, il te fait déjà passer par le format Int puis String:

Code :

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

1
2
int chrono = int.Parse(valeurHexa, System.Globalization.NumberStyles.HexNumber );
string affichChrono = Convert.ToString(chrono);

**Narizuke** · 24/04/2012, 10h22

Code :

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

1
2
3
4
5
6
7
8
9
 
  //Convertit un tableau d'octets en une chaîne formatée de chiffres hexadécimaux.
        private string ByteArrayToHexString(byte[] data)
        {
            StringBuilder sb = new StringBuilder(data.Length * 3);
            foreach (byte b in data)
                sb.Append(Convert.ToString(b, 16).PadLeft(2, '0').PadRight(3, ' '));
            return sb.ToString().ToUpper();
        }

Ce code me renvoie une chaîne de chiffre hexa, mais comment faire ensuite pour traduire cette chaîne ?

Et si je modifie mon code en mettant sp.ReadExisting()

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
 
 private void port_DataReceived(object sender, SerialDataReceivedEventArgs e)
        {
            // Si le port est ouvert, le fermer
            if (!sp.IsOpen) return;
 
            // Obtenir le nombre d'octets en attente dans le tampon du port
            string bytes = sp.ReadExisting();
 
            // Créez une zone tampon (tableau d'octets) pour stocker les données entrantes
            //byte[] buffer = new byte[bytes];
 
            // Lire les données du port et de le stocker dans la mémoire tampon
            //sp.Read(buffer, 0, bytes);
 
            // Montrer à l'utilisateur les données entrantes dans un format hexadécimal
            Log(LogMsgType.Incoming, bytes);
        }

J'obtiens ce genre de caractère : ??~~??`f?~~??

**synolog** · 24/04/2012, 10h44

Et que reçois tu en Hexa?
Un exemple de chaîne nous aidera.

**Narizuke** · 24/04/2012, 10h47

En Héxa, je reçois ça :

Code :

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

18 66 60 00 18 98 18 66 1E 06 7E 7E E6 80

Cela correspond à une pression sur le bouton du chrono.

**synolog** · 24/04/2012, 11h02

Ta doc te précise en quoi la sortie se trouve ? MiliSec?
Et quel format est attendu??
Et quel valeur sur ton chrono correspond à cette chaine??

**Narizuke** · 24/04/2012, 11h07

Voilà comment ça doit sortir :
00:16'10"18

**synolog** · 24/04/2012, 11h27

Cela ne semble pas possible avec les hexa.
Ou alors plusieurs temps sont données.
As tu essayé de travaillé directement avec les bytes?
On pourrait ainsi comparer si la valeur est correcte ou non.

**Narizuke** · 24/04/2012, 11h40

Pour travailler directement avec les bytes, tu procèdes comme ceci :

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
 
        private void port_DataReceived(object sender, SerialDataReceivedEventArgs e)
        {
            // Si le port est ouvert, le fermer
            if (!sp.IsOpen) return;
 
            // Obtenir le nombre d'octets en attente dans le tampon du port
            int bytes = sp.ReadByte();
 
            // Créez une zone tampon (tableau d'octets) pour stocker les données entrantes
            //byte[] buffer = new byte[bytes];
 
            // Lire les données du port et de le stocker dans la mémoire tampon
            //sp.Read(buffer, 0, bytes);
 
            // Montrer à l'utilisateur les données entrantes dans un format hexadécimal
            Log(LogMsgType.Incoming, bytes.ToString());
        }

ou ceci :

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
 
        private void port_DataReceived(object sender, SerialDataReceivedEventArgs e)
        {
            // Si le port est ouvert, le fermer
            if (!sp.IsOpen) return;
 
            // Obtenir le nombre d'octets en attente dans le tampon du port
            int bytes = sp.ReadByte();
 
            // Créez une zone tampon (tableau d'octets) pour stocker les données entrantes
            byte[] buffer = new byte[bytes];
 
            // Lire les données du port et de le stocker dans la mémoire tampon
            sp.Read(buffer, 0, bytes);
 
            // Montrer à l'utilisateur les données entrantes dans un format hexadécimal
            Log(LogMsgType.Incoming, ByteArrayToHexString(buffer));
        }

**synolog** · 24/04/2012, 11h45

Envoyé par Narizuke

Pour travailler directement avec les bytes, tu procèdes comme ceci :

Euh on s'est mal compris, je te demandais une chaîne de tes bytes que tu recois (avant la conversion en hexa)

**Narizuke** · 24/04/2012, 11h48

Ah ok, excuse moi, je fais ça et je te dis ce que je reçois

**Narizuke** · 24/04/2012, 11h54

ça serait plus probable si ça ressemblait à un truc dans le genre :
122332

**synolog** · 24/04/2012, 11h57

Envoyé par Narizuke

ça serait plus probable si ça ressemblait à un truc dans le genre :
122332

Je ne pense pas que cela soit les bytes que tu reçois

**Narizuke** · 24/04/2012, 12h01

Erreur de ma part désolé, mauvais copié/coller

Je referais ça tout à l'heure.

En tout cas, merci de ton aide.

**Narizuke** · 24/04/2012, 14h06

Malgré toutes les manipulations que j'ai pu faire, impossible d'obtenir un truc qui ressemble à des bytes

**synolog** · 24/04/2012, 14h16

Essai ca :

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
 private void port_DataReceived(object sender, SerialDataReceivedEventArgs e)
        {
            // Si le port est ouvert, le fermer
            if (!sp.IsOpen) return;
 
            // Obtenir le nombre d'octets en attente dans le tampon du port
            int bytes = sp.ReadByte();
 
            // Créez une zone tampon (tableau d'octets) pour stocker les données entrantes
            byte[] buffer = new byte[bytes];
 
            // Lire les données du port et de le stocker dans la mémoire tampon
            sp.Read(buffer, 0, bytes);
 
            string myByte = Encoding.UTF8.GetString(buffer);
 
            Log(LogMsgType.Incoming,myByte);
        }