Communication entre deux programmes c# par USB

Bonjour,

Je suis actuellement en DUT (réseau et télécom) et au cour de ma seconde année je doit effectuer un projet tuteuré. Ce sujet c'est révélé très compliqué car nous avons pris (mon binôme et moi même) de la progra en c# que nous n'étudions pas du tout en cour ! Bon on c'est bien démerdé jusqu'à maintenant (enfin surtout moi mon binôme est allergique à la progra). Mais j'arrive maintenant à une semaine du dossier final et il me reste deux petit bout de prog que j'arrive pas à faire avec mon niveau.

Je vous explique donc en gros le morceau du système qui va nous intéresser. On a un module radio connecté en usb à un PC. Jusqu'à présent ce module avait pour rôle de réceptionner des messages radios et de les transmettre au PC. Il faut qu'après ma reprogra il puisse recevoir un message du PC et donc qu'il écoute l'usb. Or dans les librairies fournit avec ces modules on possède un commande pour émettre sur l'usb mais pas pour écouter ! J'aimerai donc un coup de pouce afin de savoir comment créer cette commande 8-)

Je vous donne ci-dessous les infos qui me semble nécessaire à la réalisation de cette commande :

La commande

Code:

SerialDump.print("\n ALARM : PERSONNE SURVEILLEE EST ALONGEE\n");

Permet actuellement de remonter le message voulu au PC.

Cette commande se trouve dans une librairie appelé Crossbow.lib.utils et voici ce qui se rapporte à cette commande dans la librairie en question :

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
35
36
37
38
39
40
41
42
43
44
 
00013 using System;
00014 using Microsoft.SPOT;
00015 
00016 namespace Crossbow.lib.utils
00017 {
00018 
00019     public class SerialDump
00020     {
00021         public static void print(byte[] str)
00022         {
00023             string outputString = null;
00024             if (str.Length == 0) return;
00025             try
00026             {
00027                 for (int i = 0; i < str.Length; i++)
00028                 {
00029                     string tmp = str[i].ToString() + " ";
00030                     outputString += tmp;
00031                 }
00032 
00033                 Debug.Print(outputString);
00034             }
00035             catch (Exception ee)
00036             {
00037                 Debug.Print(ee.ToString());
00038             };
00039         }
00040 
00041         public static void print(string str)
00042         {
00043             if (str.Length == 0) return;
00044             try
00045             {
00046                 Debug.Print(str);
00047             }
00048             catch (Exception ee)
00049             {
00050                 Debug.Print(ee.ToString());
00051             }
00052            
00053         }
00054     }
00055 }

Je vois bien qu'il fait utiliser une commande de la librairie System.Diagnostics mais alors laquelle et comment ? Sa me dépasse un peu :roll:

Maintenant j'ai aussi un second problème qui se trouve cette fois ci du côté PC. J'ai un programme qui permet d'écouter l'usb en permanence afin d'afficher les messages entrant. J'aimerai modifier ce programme afin non plus qu'il écoute mais qu'il puisse émettre des requêtes sur l'usb. Je comprend pas beaucoup de chose à ce programme, j'arrive à voir le rôle de chaque fonction mais je ne sais pas trop comment faire une fonction pour émettre.

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
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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
 
using System;
using System.IO;
using System.Text;
using System.Collections;
using System.Reflection;
using System.Threading;
using System.Diagnostics;
 
using _DBG = Microsoft.SPOT.Debugger;
using _WP  = Microsoft.SPOT.Debugger.WireProtocol;
 
namespace Microsoft.SPOT.Tools
{
    class SerialDump
    {
        _DBG.Engine m_eng;
        FileStream  m_output;
        bool        m_fTimestamp;
        bool        m_fUsb = true;
        bool        m_fNewLine = true;
 
        //--//
 
        SerialDump( string[] args )
        {
            _DBG.PortDefinition pd       = null;
            string              port     = null;
            uint                baudrate = 0;
 
            for(int i=0; i<args.Length; i++)
            {
                string arg = args[i];
 
                if(String.Compare( arg, "-dump", true ) == 0)
                {
                    m_output = new FileStream( args[++i], FileMode.Create, FileAccess.ReadWrite, FileShare.Read );
 
                    continue;
                }
 
                if(String.Compare( arg, "-timestamp", true ) == 0)
                {
                    m_fTimestamp = true;
 
                    continue;
                }
 
                if(String.Compare( arg, "-usb", true ) == 0)
                {
                    m_fUsb = true;
 
                    continue;
                }
 
                if (String.Compare(arg, "-serial", true) == 0)
                {
                    m_fUsb = false;
 
                    continue;
                }
 
                if(port     == null) { port     =               arg  ; continue; }
                if(baudrate == 0   ) { baudrate = UInt32.Parse( arg ); continue; }
            }
 
            if(m_fUsb)
            {
                _DBG.PortDefinition[] ports = _DBG.AsyncUsbStream.EnumeratePorts();
 
                if(port == null)
                {
                    if(ports.Length == 0)
                    {
                        System.Console.WriteLine( "No Usb SPOT device is present" );
 
                        throw new ApplicationException();
                    }
                    else if(ports.Length == 1)
                    {
                        pd = ports[0];
                    }
                    else
                    {
                        System.Console.WriteLine( "More than one USB SPOT device is present" );
                        System.Console.WriteLine( "To dump data from a specific device, choose your device from the list below and execute:" );
                        System.Console.WriteLine( "  serialdump -usb <device> " );
                        System.Console.WriteLine( "" );
 
                        //
                        // More than one usb device attached; dump list so user can choose
                        //
                        for(int i = 0; i < ports.Length; ++i)
                        {
                            System.Console.WriteLine( "Device " + i + ": " + ports[i].DisplayName );
                        }
 
                        throw new ApplicationException();
                    }
                }
                else
                {
                    foreach(_DBG.PortDefinition pd2 in ports)
                    {
                        if(port.Equals( pd2.DisplayName ))
                        {
                            pd = pd2;
                            break;
                        }
                    }
                }
            }
 
            if(pd == null)
            {
                if(port     == null) port     = "COM1";
                if(baudrate == 0   ) baudrate = 115200;
 
                pd = _DBG.PortDefinition.CreateInstanceForSerial( port, port, baudrate );
            }
 
            m_eng = new _DBG.Engine( pd );
        }
 
        void Run()
        {
            m_eng.Silent = true;
 
            m_eng.Start();
 
            m_eng.OnNoise   += new _DBG.NoiseEventHandler  ( OnNoise   );
            m_eng.OnMessage += new _DBG.MessageEventHandler( OnMessage );
 
            Console.WriteLine( "####### PRESS RETURN TO EXIT #######" );
            Console.ReadLine();
 
            m_eng.Stop();
            m_eng = null;
        }
 
        void OnNoise( byte[] buf, int offset, int count )
        {
            HandleOutput( buf, offset, count );
        }
 
        void OnMessage( _WP.IncomingMessage msg, string text )
        {
            byte[] buf = Encoding.ASCII.GetBytes( text );
 
            HandleOutput( buf, 0, buf.Length );
        }
 
        void HandleOutput( byte[] buf, int offset, int count )
        {
            while(count-- > 0)
            {
                if(m_fTimestamp)
                {
                    if(m_fNewLine)
                    {
                        HandleOutput( String.Format( "[{0:HH:mm:ss:fff}]  ", DateTime.Now ) );
                    }
                }
 
                char c = (char)buf[offset++];
 
                HandleOutput( new String( c, 1 ) );
 
                m_fNewLine = (c == '\n');
            }
        }
 
        void HandleOutput( string text )
        {
            Console.Write( text );
 
            byte[] buf = Encoding.ASCII.GetBytes( text );
 
            if(m_output != null) m_output.Write( buf, 0, buf.Length );
        }
 
        //--//
 
        static void Main( string[] args )
        {
            try
            {
                SerialDump o = new SerialDump( args );
 
                o.Run();
            }
            catch(ApplicationException)
            {
                System.Threading.Thread.Sleep(5000);
            }
            catch(Exception e)
            {
                Console.WriteLine( "{0}", e.ToString() );
            }
        }
    }
}

J'arrive à comprendre vite fait que ce programme établie une connexion avec le module si celui est présent (Je précise aussi qu'on utilise que la connexion usb jamais de serial !). Puis que celui-ci fait appel à la fonction OnMessage pour récupérer les info qui lui sont envoyé pour les afficher.

En gros il me faudrait juste une fonction pour envoyer un message sur la connexion établie. Je sais pas si c'est difficile à réaliser, je ne pense pas, mais bon en tous cas c'est au dessus de mes compétences ! :cry:

Voila c'est les deux problèmes qu'il me reste à traiter j'ai réussi à faire tous le reste de mon projet seul 8-). Un grand merci à tous ceux qui pourrait me donner un coup de main ;)

Si vous avez besoin de quoi que ce soit comme info supplémentaires demandez moi ! Si vous avez déjà un début de réponse ca me va très bien aussi :P