Re-Bonjour a tous, je suis mega bloque depuis une bonne semaine........A l'aide!!
J'attends dans une routine une lecture de 1024 bytes sur le port COM que je dois lire par paquet de 64 bytes. Mon probleme est que je n'arrive pas a lire l'event de reception qui a lieu dans la routine dediee dans une autre partie du soft. Du coup je me retrouve bloque et il me faudrait sortir de cette routine de lecture pour que l'event de reception puisse etre leve, puis retour dans ma routine de lecture....bref, comment est-il possible par exemple de mettre un flag a 1 dans ma routine de reception, sachant que cette routine de reception doit pouvoir venir interrompre l'execution de ma routine d'attente de mise a 1 de ce flag? Ou bien est-il possible de faire autrement??? Si c'est pas clair, je peux  donner plus de details!!

Merci,
Florent

Salut,

En effet c'est pas clair

Tu aurais un exemple de code sous la main ?

@+

Dédé

Non cest carrément pas clair. Pour lire dans un port COM, en général on a deux solutions :
1 - s'abonner a l'event datareceived de l'objet serialport et lire dans la méthode handler de l'event
2 - créer un thread, puis lire en boucle dans ce thread. A priori dans ton cas, le mieux est d'utiliser cette solution. tu lis les données en boucle jusqu'a ce que ta trame soit complète, et une fois que cest le cas, tu la traite, puis tu te remet en attente de lecture (le mieux étant de fournir cette trame à un autre thread qui s'occupera de gérer tout ca, pour ne pas interrompre la lecture au cas ou quelque chose d'autre arriverait)

Sinon, tu peux aussi utiliser la propriété BaseStream de ton SerialPort, et là tu peux mettre ce que tu veux comme Stream avec. De plus, tu peux l'utiliser en asynchrone, ce qui ne nécessitera pas de gérer un autre thread (comme gérer l'arret de ce thread à l'arret du programme).

OK, voici en resume/simplifie ce que j'ai:

routine pour la requete de 256 bytes:

    private void Button_Readfromdevice(object sender, EventArgs e)
        {
          .....
                COMport.Write(buffer, 0, 19);  // requete pour 64 bytes
               while (flag_received != true);
                flag_received = false;
               Read_64Bytes_from_Buffer();
              
               COMport.Write(buffer, 0, 19);  // requete pour 64 bytes supplementaires
               while (flag_received != true);
                flag_received = false;
               Read_64Bytes_from_Buffer();
               COMport.Write(buffer, 0, 19);  // requete pour 64 bytes supplementaires
               while (flag_received != true);
                flag_received = false;
               Read_64Bytes_from_Buffer();
               COMport.Write(buffer, 0, 19);  // requete pour 64 bytes supplementaires
               while (flag_received != true);
                flag_received = false;
               Read_64Bytes_from_Buffer();

               // 256 bytes recus
        }


routine de reception com port:
       
public static void comport_DataReceived(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)
        {
          flag_received = true;
         }


Je commence a croire qu'il me faut faire du multi threading, mais pour le moment rien ne fonctionne du tout!!
En fait sur un microcontrolleur on a une interruption de generee lorsque je recois une trame sur le COM, mais je n'arrive pas a faire qqchose de similaire sur le visual C#. Je reste desesperement  bloque sur le test du flag de reception....

Ton aide/suggestions sont grandement les bienvenus!! Et si c'est tjrs pas clair, n'hesite pas a me le faire savoir!
Merci,
Florent

Essaie ce code :
            byte[] requette;
            //requete pour 64 bytes
            COMPort.Write(requette, 0, 19);

            List<byte> trame = new List<byte>();
            byte[] buffer = new byte[64];
            while (trame.Count < 1024)
            {
                //Réception de 64bits
                COMPort.BaseStream.Read(buffer, 0, buffer.Length);
                //stocke le buffer dans la trame
                trame.AddRange(buffer);
            }
            //Récupère le buffer complet
            buffer = trame.ToArray();
Pas besoin de gérer l'évènement "DataReveived"

Si ça ne marche pas, je t'en mettrait un autre avec de l'asynchrone...

Merci pour ta reponse super rapide, je vais essayer cela de suite! Serais-t-il possible que tu me mette l'autre version aussi, asynchrone?? J'ai essaye gras de chose a ce sujet, avec des begininvoke et autres trucs tordus, ca n'a jamais marche!!!

Merci bcp pour ton aide,
Florent

Re-salut,
Je viens d'essayer mais les valeurs retournees dans le buffer sont tres bizarres, je me prends pas mal de 0x1f au debut de la trame et le reste des data semblent erronées...Lors de mes precedents essais, j'avais remarque que ca marchait tjrs si j'attendais l'event data_received. Par contre lors de mes essais precedents je faisais un while (COMPort.BytesToRead <= 64); mais ca me donnait aussi au final des data erronees...Est-il possible d'implementer la methode asynchrone dont tu m'as parle?

Merci encore pour l'aide!
Florent

Essaie avec celui-là :

            byte[] requette;
            //requete pour 64 bytes
            COMPort.Write(requette, 0, 19);

            List<byte> trame = new List<byte>();
            byte[] buffer = new byte[64];
            while (trame.Count < 1024)
            {
                //Réception de 64bits
                int read = COMPort.BaseStream.Read(buffer, 0, buffer.Length);
                //stocke le buffer dans la trame
                for (int i = 0; i < read; i++)
                {
                    trame.Add(buffer[i]);
                }
            }
            //Récupère le buffer complet
            buffer = trame.ToArray();


Tes données erronées en début, je ne sais pas... C'est peut-être un résidu de ce qu'il y a dans le buffer de ton port.
Avant d'envoyer ta requête, essaie d'ajouter :
            COMPort.DiscardInBuffer();

Je vois pour te faire la version asynchrone...

Version asynchrone :

        private System.IO.Ports.SerialPort COMPort;
        private byte[] buffer;
        private List<byte> trame;

        private void StartRead(byte[] requette)
        {
            //requete pour 64 bytes
            COMPort.DiscardInBuffer();
            COMPort.Write(requette, 0, 19);

            trame = new List<byte>();
            buffer = new byte[64];
            COMPort.BaseStream.BeginRead(buffer, 0, buffer.Length, this.COMPort_Read, null);
        }

        private void COMPort_Read(IAsyncResult result)
        {
            //Fin de lecture
            int read = COMPort.BaseStream.EndRead(result);
            for (int i = 0; i < read; i++)
            {
                trame.Add(buffer[i]);
            }
            if (trame.Count >= 1024)
            {
                //Trame complète lue
            }
            else
            {
                //Continue à recevoir
                COMPort.BaseStream.BeginRead(buffer, 0, buffer.Length, this.COMPort_Read, null);
            }
        }

Tu appelles "StartRead" avec ta requête, et tu fais ton traitement de trame complète à l'endroit où c'est marqué "trame complète lue".

Voilàààààà

@+

Dédé