Discussion :

[Couin]

Bonjour,

Je cherche depuis 2 jours mais je cale complètement, aucun exemple trouvé sur le net ne correspond ou ne fonctionne

Voilà, je suis en train de faire une appli permettant de paramétrer un appareil via port com et liaison infra rouge (un petit module USB - IRDA qui est vu comme un port COM) afin de remplacer une "pocket" (un Palm, avec appli constructeur intégré, et port infra rouge) .
J'ai pu récupérer les codes envoyés par le Palm via 232Analyzer.
En décimal, ils se présentent sont cette forme, par exemple :
016 002 002 002 016 003

Pour l'envoi, je fais comme ceci :
Commande = Chr(16) & Chr(2) & Chr(2) & Chr(2) & Chr(16) & Chr(3)
MSComm1.Output = Commande
Cela fonctionne, l'appareil reçoit bien l'ordre et exécute la fonction correspondante.

En revanche, pour récupérer ce que l'appareil renvoi comme code (sous la même forme, toujours visualisé avec 232Analyzer), par exemple, si je relis la config de l'appareil, j'ai ceci, si les valeurs de ses paramètres sont bons :
016 002 067 032 003 002 196 009 196 009 020 000 118 016 003 (aussi, elle est répétée plusieurs fois lors de la lecture)

L'idée étant de lire par exemple la config et de comparer avec une valeur définie et dire si elle est conforme ou non.
De même pour les accusés de réceptions des différents ordres de test.
Toutes les communications commencent par 016 002 et finissent par 016 003.

Je pense dans un premier m'inspirer d'un code comme celui ci pour visualiser le code recu (on vera après pour le stocker sous forme de valeur d'une variable, ca risque d'etre marrant aussi ça) :

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 Sub MSComm1_OnComm()
 
 
Select Case MSComm1.CommEvent
' On effectue la gestion des erreurs (cf. le modèle ci-dessus)
' Ici, on gère en fait pas grand-chose, mais c'est pour illustrer la démarche ;)
 
'liste des erreurs possibles
Case comEventBreak 'On a reçu un signal d’interruption (Break)
Case comEventCDTO ' Timeout de la porteuse
Case comEventCTSTO ' Timeout du signal CTS (Clear To Send)
Case comEventDSRTO ' Timeout du signal de réception
Case comEventFrame ' Erreur de trame
Case comEventOverrun ' Des données ont été perdues
Case comEventRxOver ' Tampon de réception saturé
Case comEventRxParity ' Erreur de parité
Case comEventTxFull ' Tampon d’envoi saturé
Case comEventDCB ' Erreur de réception DCB (jamais vu)
 
'liste des événements possibles qui sont, eux, normaux
Case comEvCD 'Changement dans la broche CD (porteuse)
Case comEvCTS 'Changement dans broche CTS
Case comEvDSR 'Changement dans broche DSR (réception)
Case comEvRing 'Changement dans broche RING (sonnerie)
 
'Chouette! on a reçu des données :)
Case comEvReceive
      tampon = MSComm1.Input
      tampon = Asc(tampon)
     Text1.SelText = (tampon) & "," 'ici, on affiche le résultat dans un champ de texte
 
Case comEvSend ' il y a des caractères à envoyer
 
Case comEvEOF 'on a reçu le caractère EOF
End Select
 
End Sub

Evidement, ca m'affiche des valeurs farfelues.

Je pense qu'il faudrait récupérer chaque octet, donc sur l'exemple de la lecture de config :
00010000 00000010 01000011 00100000 00000011 00000010 11000100 00001001 11000100 00001001 00010100 00000000 01110110 00010000 00000011

Je pense qu'il faut utiliser "InputMode = comInputModeBinary" (d’ailleurs, est-ce que cela change aussi le mode output ou je peux garder mes Chr(016) etc etc ?) , mais plus je fais d'essais plus j'ai entre rien et n'importe quoi

Je patauge complètement (en temps normal, c'est bien pour un canard , mais là nan ).

Un petit coup de palme serait bienvenu

Merci et à bientôt
Couin

[ProgElecT]

Salut

J'avais un programme qui nécessitait une conversion binaire vers décimale et inversement, du coup je te propose un une version simplifié.
Dans un projet, un module.BAS et un Form avec 4 CommandButtons et 3 TextBoxs,
Code du Module1.BAS

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
Option Explicit
 
Dim Binnaire(16) As Long
Dim T As Double, U As Integer
 
Public Sub Main()
For T = 1 To 16: Binnaire(T) = 2 ^ (T - 1): Next T
Form1.Show
End Sub
 
Public Function Bin8_Dec(ValBin As String) As Integer
    'exemple: 11100011 = 227
    Dim StrDonn As String
    StrDonn = CStr(ValBin)
    U = Len(StrDonn)
    For T = 1 To U
        If Mid$(StrDonn, T, 1) = 1 Then Bin8_Dec = Bin8_Dec + Binnaire(U - (T - 1))
    Next T
End Function
 
Public Function Dec_Bin8(ValDec As Integer) As String
    'exemple: 227 = 11100011
    U = 8
    For T = 1 To 8
        If ValDec >= Binnaire(U - (T - 1)) And ValDec <> 0 Then
            Dec_Bin8 = Dec_Bin8 & "1": ValDec = ValDec - Binnaire(U - (T - 1))
            Else
            Dec_Bin8 = Dec_Bin8 & "0"
        End If
    Next T
End Function

Code du Form1.frm

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
Option Explicit
Dim TT As Integer
Dim TextRecupe As String
 
Private Sub Form_Load()
    Me.Height = 3645: Me.Width = 5205: Me.Caption = "Convertisseur"
 
    Text1.FontName = "Courier New"
    Text1.FontSize = 8
    Text1.Move 120, 60, 4740, 795
    Text1.BorderStyle = 1
    Text1.Appearance = 0
    'Text1.MultiLine = True <------------ A faire en desing -------------
    Text1.Text = "00010000 00000010 01000011 00100000 00000011 00000010 11000100 00001001 11000100 00001001 00010100 00000000 01110110 00010000 00000011"
 
    Command1.Move 120, 900, 2355, 435: Command1.Caption = "^-- Binnaire ---> Décimale --v"
    Command2.Move 2555, 900, 2295, 435: Command2.Caption = "v-- Décimale ---> Binnaire --^"
 
    Text2.FontName = "Courier New"
    Text2.FontSize = 8
    Text2.Move 120, 1380, 4740, 555
    Text2.BorderStyle = 1
    Text2.Appearance = 0
    'Text2.MultiLine = True <------------ A faire en desing -------------
    Text2.Text = ""
 
    Command3.Move 120, 1980, 2355, 435: Command3.Caption = "^-- Ascii ---> caractère --v"
    Command4.Move 2555, 1980, 2295, 435: Command4.Caption = "v-- caractére ---> Ascii --^"
 
    Text3.FontName = "Courier New"
    Text3.FontSize = 8
    Text3.Move 120, 2460, 4740, 555
    Text3.BorderStyle = 1
    Text3.Appearance = 0
    'Text3.MultiLine = True <------------ A faire en desing -------------
    Text3.Text = ""
 
End Sub
 
Private Sub Command1_Click()
    If Trim(Text1.Text) = "" Then Exit Sub
    Dim ArrayDataBin() As String
    ArrayDataBin = Split(Trim(Text1.Text), " ")
    TextRecupe = "": Text2.Text = ""
    For TT = 0 To UBound(ArrayDataBin)
        TextRecupe = TextRecupe & CStr(Bin8_Dec(ArrayDataBin(TT))) & " "
    Next TT
    TextRecupe = Left(TextRecupe, Len(TextRecupe) - 1)
    Text2.Text = TextRecupe
End Sub
 
Private Sub Command2_Click()
    If Trim(Text2.Text) = "" Then Exit Sub
    Dim ArrayDataDec() As String
    ArrayDataDec = Split(Trim(Text2.Text), " ")
    TextRecupe = "": Text1.Text = ""
    For TT = 0 To UBound(ArrayDataDec)
        TextRecupe = TextRecupe & CStr(Dec_Bin8(CInt(ArrayDataDec(TT)))) & " "
    Next TT
    TextRecupe = Left(TextRecupe, Len(TextRecupe) - 1)
    Text1.Text = TextRecupe
End Sub
 
Private Sub Command3_Click()
    If Trim(Text2.Text) = "" Then Exit Sub
    Dim ArrayDataCaract() As String
    ArrayDataCaract = Split(Trim(Text2.Text), " ")
    TextRecupe = ""
    For TT = 0 To UBound(ArrayDataCaract)
        If CInt(ArrayDataCaract(TT)) = 0 Then
            TextRecupe = TextRecupe & "NULL"
            Else
            TextRecupe = TextRecupe & Chr(CInt(ArrayDataCaract(TT)))
        End If
    Next TT
    Text3.Text = TextRecupe
End Sub
 
Private Sub Command4_Click()
    If Trim(Text3.Text) = "" Then Exit Sub
    Dim StrSoumis As String
    StrSoumis = Trim(Text3.Text)
    TextRecupe = "": Text2.Text = ""
    For TT = 1 To Len(StrSoumis)
        If (TT - 4) <= Len(StrSoumis) Then
            If Mid(StrSoumis, TT, 4) = "NULL" Then
                TextRecupe = TextRecupe & "0 ": TT = TT + 3
                Else
                TextRecupe = TextRecupe & AscW(Mid(StrSoumis, TT, 1)) & " "
            End If
            Else
            TextRecupe = TextRecupe & AscW(Mid(StrSoumis, TT, 1)) & " "
        End If
    Next TT
    TextRecupe = Left(TextRecupe, Len(TextRecupe) - 1)
    Text2.Text = TextRecupe8
End Sub

Dans le TextBox du haut tu peux y mettre différent octets sur 8 bits en les séparent par un caractère espace (" ") , en cliquant sur le premier CommandButton tu obtiens la conversion en décimale, puis en cliquant sur le bouton ^-- Ascii ---> caractère --v tu obtiens la conversion en caratères.
Inversement, tu peux partir du TextBox le plus bas pour écrire du texte pour le convertir en code ascii puis en équivalence octets sur 8bits.
A savoir, un octet égal à null (00000000) sera converti en un mot égal à NULL, inversement si tu veux obtenir un octet 00000000 tu écris NULL dans le TextBox le plus bas, ce qui donne 0 (zéro) en décimale et 00000000 en octet 8bits.

Si tu entre: 016 002 067 032 003 002 196 009 196 009 020 000 118 016 003 dans le TextBox du milieu, tu obtiens 00010000 00000010 01000011 00100000 00000011 00000010 11000100 00001001 11000100 00001001 00010100 00000000 01110110 00010000 00000011 pour la conversion octets et voir l'image pour la conversion en caractères.

[Couin]

Hello,

Désolé pour mon passage tardif, merci pour ta réponse Je garde ça sous l'aile

Je suis entretemps parvenu à réceptionner les données voulues et les exploiter en décimal (encore mieux pour l'écriture du programme ).

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
 
Private Sub Form_Load()
MSComm1.CommPort = 3
MSComm1.Settings = "115200,n,8,1"     'port settings
MSComm1.RTSEnable = True            'makes pin 4 high (12V)
MSComm1.RThreshold = 1
MSComm1.InputMode = comInputModeBinary
cmdClose.Enabled = False
End Sub
 
 
Private Sub GetDataTimer_Timer()
    If MSComm1.InBufferCount > 0 Then
        ReadDataBits
    End If
End Sub
 
'----------------------------------------------------------END----------------------------------------------------------
'Read The Data From The Com Port And Display As A Binary String per Byte Received
'---------------------------------------------------------START---------------------------------------------------------
Private Sub ReadDataBits()
        Dim bytInput() As Byte
        Dim bytElement As Byte
        Dim sLead As String
        Dim sDisplay As String
        Dim sToget As String
        Dim iX As Long
        Dim iY As Long
 
        If MSComm1.InBufferCount = 0 Then            'Check The Buffer For Data
        Exit Sub                                        'Exit If The Buffer Is Empty
        End If
 
        bytInput = MSComm1.Input
        iX = UBound(bytInput)                               'Get the number of byte elements in the input
 
        For iY = 0 To iX
            bytElement = bytInput(iY)                       'Get the next byte element from the input
            sLead = bytElement & " "                       'Create display lead
            sDisplay = sDisplay & sLead
        Next
        lstData.AddItem sDisplay
    Exit Sub
 
End Sub

Toutefois, je cale sur un point donc je vais ouvrir un nouveau sujet pour éviter les mélanges de réponses

A bientôt

[siosnarf69]

Salut Couin,

Avant de dépiauter les trames, il faudrait connaitre le protocole de communication utilisé par le Palm.
IR étant le mode de transport, ModBus pourrait être par exemple le protocole ?
(Je dis ca car le 16 est le code fonction d'écriture multiple d'entier en ModBus mais ca n'a pas l'air d'être ca.)

Il est difficile de trouver la structure des trames échangées avec l'exemple fourni :
016 002 067 032 003 002 196 009 196 009 020 000 118 016 003

Les données seraient : 067 032 003 002 196 009 196 009 020 000 118
Mais a quoi correspondent elles ? Est-ce de l'hexa ou du décimal envoyé par le palm ? y a il un CRC ? Une adresse du Palm ? un code fonction ? (lecture, écriture etc...) C'est chaud !

D'autre part, utilise plutôt l’événement OnComm du composant MSCOM pour la réception de données.
a+

[Couin]

Hello,

Merci pour ta réponse

Je suis parvenu à pas mal de chose entre temps .

Tous les messages envoyés par la pocket ou répondus par l'appareil commencent par 16 2 et finissent par 16 3 .
Je ne connais pas le protocole utilisé et je ne pourrais jamais le savoir.
Pour l'exemple du read config :
016 002 067 032 003 002 196 009 196 009 020 000 118 016 003
(J'ai constaté que récemment que le read config répondait différemment si la carte de l'appareil est de première ou de deuxièmement génération).
Certains paramètres sont cryptés d'une drôle de manière (que je n'ai pas trouvée lol) mais à la limite, ce n’est pas très grave dans le sens où je compare le code lu avec un code de bonne config connue.
032 003 est le pitch (valeur 800 donc crypté), 002 est le paramètre numéro 18, valeur 2 (donc non crypté, si je mets une autre valeur le code retourne directement la valeur), 196 009 correspondent à une valeur de 2500 pour 2 paramètres (c’est pour ce qu'il y est 2 fois car les deux params sont à 2500) , 020 est là aussi directement lisible (paramètre 5, valeur 20), 000 est un autre paramètre , là aussi directement lisible. 118 doit être un CRC car quelque soit le paramètre que je change, il est toujours différent.
De ce fait en splittant le code je peux isoler chaque paramètre lu et dire lequel n’est pas bon quand il y a une erreur de conf.

Je pense que le protocole est totalement propriétaire (le constructeur de la machine fabrique la carte électronique et le logiciel pour communiquer avec donc il a pu mettre ce qu'il voulait lol).

Je vais étudier la méthode OnComm, l'idée étant de virer le timer, c'est bien ca ?

[siosnarf69]

Salut Couin,

Effectivement tu n'es pas obligé de comprendre les trames (ouf! ) si ton objectif est de comparer ce que tu reçois par rapport à une config correcte.
Oui pour le OnComm(), tu pourras virer le Timer.
Grace à un

Code :

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

1
2
3
MSCom_OnComm()
Select Case MSCom.CommEvent
  case comEvReceive

Tu pourras gérer ton buffer de com MSCom.Input de manière événementielle, au moins tu es sur de ne rien rater.

Idem pour les autres constantes (comEvCTS, comEvCD, etc...) , ca te permettra de savoir vraiment ce qu'il se passe sur le port de com.

Et pour info, c'est quoi le modèle de ton convertisseur USB-IRDA ?

Bon courage !

[Couin]

En ce qui concerne le buffer du port COM, actuellement le timer check si il y a quelque chose dedans et si il y a quelque chose, j'envoie le contenu dans une variable string que j'analyse ensuite. A priori ca a l'air de fonctionner aussi.

Pour le convertisseur IrDA-USB je te redirais lundi soir

[Couin]

Reu !

Le module USB - IRDA est un actisys act-ir224un-ln115 http://www.actisys.com/IrDAProd.html#IR224UN

[siosnarf69]

Merci Couin ^^

[Couin]

De rien

Au passage, j'ai tenté la migration vers l’événement OnComm, mais ça me ramassait pas les trames que par petits bouts et du coup la comparaison ne pouvait se faire.
Ou alors il faudrait un truc du genre "Si rien reçu depuis x millisecondes, on exécute telle fonction".

[siosnarf69]

C'est que le Palm doit envoyer plusieurs trames car l’événement OnComm() ne se déclenche que lorsque ton buffer reçoit quelque chose.

[Couin]

En l’occurrence le Palm n'est pas en cause car l'appli reçoit ce que l'équipement (sur lequel on travaille avec le Palm pour le moment) répond. En gros le logiciel que je ponds remplace le Palm.
Mais comme ils communiquent les trames sont les mêmes.

Je pense que le traitement de ce que ramasse l'évent OnComm, est trop rapide et du coup au lieu d'avoir un code du genre 16 2 67 32 3 2 196 9 196 9 20 0 118 16 3 on a
16 2
67 32 3
2 196
9 196 9
20 0
118 16
3
Par exemple.
Comme le traitement des données reçue se fait une fois le buffer vide, bah il n'y a que des petits bouts à traiter.