Discussion :

[megamario]

Bonjour à tous,

Petite question pour savoir si je fait bien les choses.
Je suis partie d'un code existant et apparemment fonctionnel, mais avec un autre matériel. Avec le nouveau cela ne fonctionne pas, j'ai donc refait le code et cela marche mais j'ai un doute sur la démarche.

j'interroge un composant par le port COM, et sa trame de retour est la suivante:

0xAA 0x00 0x22 0x00 0x03 0x00 0x00 0x09 0x4F 0x00 0x45 0xC2

Cette ligne me donne une longueur (valeur en gras) 0x00 0x00 0x09 0x4F, puis l'octet suivant 0x00 0x45 la qualité du signal.

la longueur est ici équivalente 0x94F = 2383mm
la qualité du signal vous l'avez compris = 0x45

Pour récupérer ces valeurs je fait :

Code :

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

1
2
3
4
5
 
//Pour récupérer la longueur
//bytes2 étant ma trame de retour du port COM
byte[] bytes3 = { bytes2[9], bytes2[8], bytes2[7], bytes2[6] };
Int32 res = BitConverter.ToInt32(bytes3, 0);

Code :

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

1
2
3
4
5
 
//Pour récupérer la qualité du signal
//bytes2 étant ma trame de retour du port COM
byte[] bytes3 = { bytes2[10], bytes2[9]};
Int16 res = BitConverter.ToInt16(bytes3, 0);

Obligé de passer par une conversion ToInt32 puis ToInt16

Cela fonctionne, mais n'y aurait pas un autre moyen sans passer pas la création d'un 3eme tableau de bytes (le 1er étant ma trame de commande).
Et surtout sans avoir a faire une conversion spécifique tels que le ToInt32 ou ToInt16.

Pour le moment toutes mes réponses dans les trames ce limite à 1 ou 2 octets, donc ce n'est pas trop gênant, mais s'il y a moyen d'optimisé cela je suis preneur.

merci

[PixelJuice]

Bonjour,

Je m'étais déjà penché la dessus, étant assez mécontent du fonctionnement du convertisseur, du coup tu peux utiliser ça pour avoir une conversion rapide et sans devoir créer de nouveau tableau

Code :

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

1
2
3
4
5
6
7
8
9
     public static short Convert(byte A, byte B)
     {
         return (short)((B << 8) + A);
     }
 
     public static int Convert(byte A, byte B, byte C, byte D)
     {
         return (D << 24) + (C << 16) + (B << 8) + A;
     }

Tu peux facilement l'adapter pour prendre directement un index, et un compteur pour directement l'utiliser dans un tableau etc ...

Il y a encore plus rapide mais cela nécessite du code unsafe (en utilisant les pointeurs)

Mais dans ton cas, je pense pas que ça soit si important, d'ailleurs la création d'un troisième tableau est inutile, autant donner ton buffer et le bon index directement

[François DORIN]

Tu peux regarder du côté de BinaryReader, qui offre la possibilité de lire des flux via des méthodes styles ReadInt16, ReadInt32

[megamario]

Bonjour,

Je m'étais déjà penché la dessus, étant assez mécontent du fonctionnement du convertisseur, du coup tu peux utiliser ça pour avoir une conversion rapide et sans devoir créer de nouveau tableau

Code :

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

1
2
3
4
5
6
7
8
9
     public static short Convert(byte A, byte B)
     {
         return (short)((B << 8) + A);
     }
 
     public static int Convert(byte A, byte B, byte C, byte D)
     {
         return (D << 24) + (C << 16) + (B << 8) + A;
     }

Tu peux facilement l'adapter pour prendre directement un index, et un compteur pour directement l'utiliser dans un tableau etc ...

Il y a encore plus rapide mais cela nécessite du code unsafe (en utilisant les pointeurs)

Mais dans ton cas, je pense pas que ça soit si important, d'ailleurs la création d'un troisième tableau est inutile, autant donner ton buffer et le bon index directement

Merci beaucoup, c'est vrai je me souvenais plus de cette possibilité <<, merci.

[ypelissier]

Bonsoir,
J'ai eu à traiter ce genre de problématique aussi il y a quelques temps et j'ai utilisé ceci :

Code C# :

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
 
        public static int ToInt(this byte[] This, int index = 0)
            => (int)(This.ToValue(index, 4) % int.MaxValue);
 
        public static long ToValue(this byte[] This, int startPosition = 0, byte length = 2, )
        {
            if (length > 8)
                throw new OverflowException("La longueur du tableau d'octets à convertir ne peut pas être supérieure à 8");
 
            var bytes = This.SubBytes(startPosition, length);
 
            return bytes.Select((o, index) => new { o, index })
                        .Aggregate((long)0, (agg, next) => agg + next.o << 8 * next.index);
        }
 
        public static byte[] SubBytes(this byte[] This, int startIndexPosition = 0, int? length = null)
        {
            // Récupérer la position de départ
            var beginAt = This.ManageStartIndexPosition(startIndexPosition);
            // Récupérer la taille à récupérer
            var size = This.ManageLength(startIndexPosition, length);
            // Nouveau tableau d'octets
            var result = new byte[size];
 
            // Ne récupérer que les données demandées
            Buffer.BlockCopy(This, beginAt, result, 0, size);
 
            // Retour du résultat de la fonction
            return result;
        }
 
        public static int ManageStartIndexPosition(this byte[] This, int? startIndexPosition = null)
            => Math.Max(Math.Min(This.Length, startIndexPosition ?? This.Length), 0);
 
        private static int ManageLength(this byte[] This, int startIndexPosition = 0, int? length = null)
            => Math.Max(Math.Min(Math.Min(This.Length, length ?? This.Length), This.Length - startIndexPosition), 0);

[megamario]

Bonsoir,
J'ai eu à traiter ce genre de problématique aussi il y a quelques temps et j'ai utilisé ceci :

Code C# :

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
 
        public static int ToInt(this byte[] This, int index = 0)
            => (int)(This.ToValue(index, 4) % int.MaxValue);
 
        public static long ToValue(this byte[] This, int startPosition = 0, byte length = 2, )
        {
            if (length > 8)
                throw new OverflowException("La longueur du tableau d'octets à convertir ne peut pas être supérieure à 8");
 
            var bytes = This.SubBytes(startPosition, length);
 
            return bytes.Select((o, index) => new { o, index })
                        .Aggregate((long)0, (agg, next) => agg + next.o << 8 * next.index);
        }
 
        public static byte[] SubBytes(this byte[] This, int startIndexPosition = 0, int? length = null)
        {
            // Récupérer la position de départ
            var beginAt = This.ManageStartIndexPosition(startIndexPosition);
            // Récupérer la taille à récupérer
            var size = This.ManageLength(startIndexPosition, length);
            // Nouveau tableau d'octets
            var result = new byte[size];
 
            // Ne récupérer que les données demandées
            Buffer.BlockCopy(This, beginAt, result, 0, size);
 
            // Retour du résultat de la fonction
            return result;
        }
 
        public static int ManageStartIndexPosition(this byte[] This, int? startIndexPosition = null)
            => Math.Max(Math.Min(This.Length, startIndexPosition ?? This.Length), 0);
 
        private static int ManageLength(this byte[] This, int startIndexPosition = 0, int? length = null)
            => Math.Max(Math.Min(Math.Min(This.Length, length ?? This.Length), This.Length - startIndexPosition), 0);

Bonjour,

Avec un peu de retard, merci ypelissier, je vais regarder cela.

[ypelissier]

Pas de soucis, j'ai aussi pris du temps à répondre et on n'est pas toujours sur le même problème donc parfois il faut laisser un peu de temps.

Tu me diras si tu as changer des choses pour améliorer mon code aussi (c'est le but du partage de code non).