Deconnexion PC - Arduino

Version imprimable

10/08/2017, 14h20
slotizer

Deconnexion PC - Arduino

Bonjour,
je suis nouveau sur ce forum et j'aimerais faire appel à des utilisateurs bien plus avertis que moi sur le pilotage de ma carte Arduino Uno par un PC via VB6.

J'ai développé un logiciel (en VB6) qui permet de gérer des courses d'autos sur pistes plastiques (type scalextric pour ceux qui connaissent). Pour cela, j'ai besoin d'interfacer le PC avec la détection du passage des autos (j'utilise des IR de détection d'obstacle Arduino) et 2 relais (carte Arduino) qui coupent l'alimentation de chaque piste.

Tout fonctionne correctement séparément (soit la détection, soit le pilotage des relais). Dès que les deux sont opérationnels cela fonctionne "quelque temps" et d'un seul coup la carte arduino n'est plus reconnue par le PC.

Pour évacuer les problèmes d'alimentation de la carte, j'ai ajouté une alime de 12V (Vieille alime de pc) avec un résultat identique.

Je suis complètement perdu. Quelqu'un aurait une piste de recherche ??

Merci de votre aide

JFM
10/08/2017, 17h41
Auteur

bonjour,

peut-on voir ton code côté Arduino ? Dans le code VB6 comment est configuré le port série ?

Voici le code Arduino :
(seules les fonctions IR et Relais sont utilisées pour l'instant)

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
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
//  ====================  constantes  =======================
const float multiplicateur = 5.2 ;
const float ecart = 0.1 ;
const char msgvolt = 'V' ;
const char msgmessage = 'M' ;
const char msgerreur = 'E' ;
const char msgamp = 'A' ;
const char msgbouton = 'B' ;
const char msgpiste = 'P' ;
const char msglux = 'L' ;
const char msgrelai = 'R' ;
const char msguln = 'C' ;
const char msgtest = 'T' ;
const char msgfin = '/' ;
const float pource = 0.10 ;         // % pour détecter analogique
const long delailed = 800 ;            // Durée allumage LED en ms
const int comptgal =  1  ;            // Combien de signaux successifs
const int wascii = 48 ;
const int minival = 40 ;
const int maxvolt = 200 ;
const int maxampe = 5 ;
const int delailoop = 10 ;
 
//  ====================  variables  =======================
int wpiste ;
char waction ;
int wvaleur ;
int wreception = 0 ;
int jelis ;
int indice ;
int jndice ;
long tpsled[] = {0, 0, 0 } ;
int comptcell [] = {0, 0, 0} ;
int comptbout [] = {0, 0, 0} ;
float temp ;
int value = 0 ;
int amperezero [] = {0, 0} ;
int oldvolt[] = {0 , 999 , 999} ;
int oldamp[] = {0 , 999 , 999} ;
int wvalue[4] ;
int comptvolt = maxvolt ;
int comptampe = 0 ;
 
boolean flagpiste = false ;
boolean flagbouton = false ;
boolean flagvolt = false ;
boolean flagamp = false ;
boolean flagrelai = false ;
 
//   ================  Entrées Analogiques  =====================
int volt[] = {0, 0 , 1} ;
int amp[] = {0, 2 , 3} ;
// int photo = 4 ;
 
//   ================  Sorties  Digitales  =====================
int relai[] = {0 , 7 , 8 } ;
int uln[] = {0 , 9, 10 , 6} ;
int ledpasse[] = {0 , 11, 12} ;
int ledtest = 13 ;
 
//   ================  Entrées Digitales  =====================
//int wserie[] = {0 , 0 , 1} ;      //  ===  RESERVE pour Com ===
int bouton[] = {0 , 2 , 3} ;
int cell[] = {0 , 4 , 5} ;
 
void setup()
{
  //pinMode(wserie[1], OUTPUT);       //  ===  RESERVE pour Com ===
  //pinMode(wserie[2], OUTPUT);      //  ===  RESERVE pour Com ===
  pinMode(bouton[1], INPUT);         // D2
  pinMode(bouton[2], INPUT);         // D3
  pinMode(cell[1], INPUT);           // D4
  pinMode(cell[2], INPUT);           // D5
  pinMode(uln[3], OUTPUT);           // D6
  pinMode (relai[1], OUTPUT);        // D7
  pinMode (relai[2], OUTPUT);        // D8
  pinMode (uln[1], OUTPUT);          // D9
  pinMode (uln[2], OUTPUT);          // D10
  pinMode (ledpasse[1], OUTPUT);     // D11
  pinMode (ledpasse[2], OUTPUT);     // D12
  pinMode (ledtest, OUTPUT);         // D13
  pinMode(volt[1], INPUT);           // A0
  pinMode(volt[2], INPUT);           // A1
  pinMode(amp[1], INPUT);            // A2
  pinMode(amp[2], INPUT);            // A3
  //  pinMode(photo, INPUT);         // A4
  //  ===  LIBRE  ===                // A5
 
  Serial.begin(9600);
  digitalWrite(relai[1], HIGH);
  digitalWrite(relai[2], HIGH);
}
 
void loop()
{
  //  =======================  Lecture port série  ================
  if (Serial.available() > 0)
  {
    jelis = Serial.read();
    if (jelis != 10)
    {
      if (jelis != msgfin )
      {
        wreception ++ ;
        switch (wreception)
        {
          case 1 :
            waction = (char) jelis ;
            break ;
 
          case 2:
            wpiste = jelis - wascii ;
            break ;
 
          case 3:
            wvaleur = (jelis - wascii) ;
            break ;
 
          case 4:
            wvaleur = wvaleur * 10 ;
            wvaleur = wvaleur + (jelis - wascii) ;
            break ;
 
          case 5:
            wvaleur = wvaleur * 10 ;
            wvaleur = wvaleur + (jelis - wascii) ;
            break ;
 
          case 6:
            wvaleur = wvaleur * 10 ;
            wvaleur = wvaleur + (jelis - wascii) ;
            break ;
 
          default:
            Serial.print (msgerreur) ;    // Erreur
            Serial.println (msgfin) ;    // Erreur
            break;
        }
      }
      else
      {
        if (wreception < 1 )
        {
          waction = msgerreur ;
        }
 
        if (waction == msguln || waction == msglux)
        {
          wvaleur = (255 / 100) * wvaleur ;
        }
 
        switch (waction)
        {
          case  msguln:                   //  ====  Pilotage alimentation pistes  ===
            for (indice = 0 ; indice <= wvaleur ; indice++)
            {
              analogWrite(uln[wpiste], indice);
            }
            break;
 
          case msglux:                    //  ====  Pilotage alimentation Lumière  ===
            for (indice = 0 ; indice <= wvaleur ; indice++)
            {
              analogWrite(uln[3], indice);
            }
            break;
 
          case msgrelai:                  //  ====  Gestion des relais  ===
            if ( wvaleur == 1 )
            {
              digitalWrite(relai[1], LOW);
              digitalWrite(relai[2], HIGH);
            }
            if ( wvaleur == 2 )
            {
              digitalWrite(relai[2], LOW);
              digitalWrite(relai[1], HIGH);
            }
            if ( wvaleur == 0 )
            {
              digitalWrite(relai[1], HIGH);
              digitalWrite(relai[2], HIGH);
            }
            if ( wvaleur == 3 )
            {
              digitalWrite(relai[1], LOW);
              digitalWrite(relai[2], LOW);
            }
            break;
 
          case msgtest:                   //  ====  Test de démarrage  ===
            Serial.println("T");
            digitalWrite(ledtest, HIGH);
            delay(delailed) ;
            digitalWrite(ledtest, LOW);
            break;
 
          case msgbouton:                 //  ====  Gestion ou non des boutons  ===
            if ( wpiste == 1 )
            {
              flagbouton = true ;
              digitalWrite(ledpasse[2], HIGH);
              delay(delailed / 10) ;
              digitalWrite(ledpasse[2], LOW);
            }
            else
            {
              flagbouton = false ;
            }
            break;
 
          case msgpiste:                  //  ====  Gestion ou non des cellules  ===
            if ( wpiste == 1 )
            {
              flagpiste = true ;
              digitalWrite(ledpasse[1], HIGH);
              delay(delailed / 10) ;
              digitalWrite(ledpasse[1], LOW);
            }
            else
            {
              flagpiste = false ;
            }
            break;
 
          case msgvolt:                   //  ====  Gestion ou non Lecture Voltage  ===
            if ( wpiste == 1 )
            {
              flagvolt = true ;
            }
            else
            {
              flagvolt = false ;
            }
            break;
 
          case msgamp:                    //  ====  Gestion ou non Lecture Ampérage  ===
            if ( wpiste == 1 )
            {
              flagamp = true ;
              //             amperezero [1] = analogRead(amp[1]);
              //             amperezero [2] = analogRead(amp[2]);
              //Serial.print("Valeur initiale ===> ") ;
              //Serial.println(amperezero [1]) ;
              //digitalWrite(ledtest, HIGH);
            }
            else
            {
              flagamp = false ;
              //digitalWrite(ledtest, LOW);
            }
            break;
 
          default:
            Serial.print (msgerreur) ;    //  ====  Envoi Ereur au PC  ===
            Serial.println (msgfin) ;
            break;
        }
        wreception = 0 ;
      }
    }
  }
 
  if ( flagpiste == 1 )    // ======================   Détection cellules 1 & 2 ====================
  {
    for (jndice = 1 ; jndice <= 2 ; jndice++)
    {
      if (digitalRead(cell[jndice]) == LOW )
      {
        comptcell[jndice] ++ ;
        if (comptcell [jndice] < comptgal + 1)
        {
          Serial.print (msgpiste) ;
          Serial.print(jndice);
          Serial.println (msgfin) ;
          digitalWrite(ledpasse[jndice], HIGH);   // high
          tpsled[jndice] = millis();
        }
      }
      else
      {
        comptcell[jndice] = 0 ;
        if (tpsled[jndice] + delailed < millis())
        {
          digitalWrite(ledpasse[jndice], LOW);
        }
      }
    }
  }
  else
  {
    if (digitalRead (ledpasse[1]) == HIGH) {
      digitalWrite(ledpasse[1], LOW);
    }
    if (digitalRead (ledpasse[2]) == HIGH) {
      digitalWrite(ledpasse[2], LOW);
    }
  }
 
  if ( flagbouton == 1 )          // ======================   Détection Boutons 1 & 2 ====================
  {
    for (jndice = 1 ; jndice <= 2 ; jndice++)
    {
      if (digitalRead(bouton[jndice]) == HIGH )
      {
        comptbout[jndice] ++ ;
        if (comptbout [jndice] < comptgal + 1)
        {
          Serial.print (msgbouton) ;
          Serial.print(jndice);
          Serial.println (msgfin) ;
        }
      }
      else
      {
        comptbout[jndice] = 0 ;
      }
    }
  }
 
  if ( flagvolt == 1 )         //   =================== Test des volts =================
  {
    if ( comptvolt > maxvolt )
    {
      comptvolt = 0 ;
      for (indice = 1 ; indice <= 1 ; indice++)
      {
        value = analogRead(volt[indice]) ;
        if (value != 0 )
        {
          //Serial.println(value) ;
 
          temp = (value * 5.0  / 1024.0 ) * multiplicateur ;
          value = temp * 10 ;
          if (value < minival )
          {
            value = 0 ;
          }
          if (value > oldvolt[indice] * (1 + ecart) || value < oldvolt[indice] * (1 - ecart) )
          {
 
 
 
            oldvolt[indice] = value ;
            //            Serial.print("V") ;
            //            Serial.print(indice) ;
            wvalue[0] = value / 100 ;
 
            Serial.println(wvalue[0]) ;
 
            //            Serial.print(char(wvalue[0] + 48)) ;
            wvalue[1]  = (value - ( wvalue[0] * 100 )) / 10 ;
            Serial.println(wvalue[1]) ;
            //            Serial.print(char(wvalue[1] + 48)) ;
            wvalue[2] = value -  wvalue [1] * 10 - wvalue[0] * 100  ;
            Serial.println(wvalue[2]) ;
            //            Serial.print(char(wvalue[2] + 48)) ;
            //            Serial.println("/") ;
          }
        }
      }
    }
    else
    {
      comptvolt ++ ;
    }
  }
 
  if ( flagamp == 1 )     //   =================== Test des Ampères  =================
  {
    if ( comptampe > maxampe )
    {
      comptampe = 0 ;
      for (indice = 1 ; indice <= 1 ; indice++)
      {
        value = analogRead(amp[indice]);
        if (value != 0 )
        {
          temp = (value  * 5.0)  / 1024 ;
          value = temp * 1000  ;
          oldamp[indice] = value ;
          Serial.print("A");
          Serial.print(indice) ;
          wvalue[0] = value / 1000 ;
          Serial.print(char(wvalue[0] + 48)) ;
          wvalue[1]  = (value - ( wvalue[0] * 1000 )) / 100 ;
          Serial.print(char(wvalue[1] + 48)) ;
          wvalue[2] = (value -  wvalue [1] * 100 - wvalue[0] * 1000 ) / 10 ;
          Serial.print(char(wvalue[2] + 48)) ;
          wvalue[3] = value -  wvalue [2] * 10 - wvalue [1] * 100 - wvalue[0] * 1000  ;
          Serial.print(char(wvalue[3] + 48)) ;
          Serial.println("/") ;
        }
      }
    }
    else
    {
      comptampe ++ ;
    }
  }
  delay(delailoop);
}

Pour la partie VB6 :

Code:

OPENCOM("COM" & Format(WCom, "0") & ",9600,N,8,1")

Merci de te pencher sur mon problème

11/08/2017, 12h42
Auteur

bonjour,

es-tu sûr des valeurs retournées par serial.read() ?

Ensuite, avec certains programmes, si tu coupes la communication série brutalement, tu es obligé de réinitialiser l'Arduino pour rétablir la communication. Pour éviter cela il faut que le flag DTR soit à true. Regarde si c'est possible en VB6.
11/08/2017, 13h11
Vincent PETIT

Salut,
Où as tu acheté ton Arduino UNO ?

Je trouve très surprenant que le PC ne voit plus l'Arduino (le port série virtuel). Je ne parle pas de la remarque de Auteur.
11/08/2017, 15h10
slotizer

Citation:

Envoyé par Auteur

bonjour,

es-tu sûr des valeurs retournées par serial.read() ?

Oui car cela fonctionne pendant quelques temps

Ensuite, avec certains programmes, si tu coupes la communication série brutalement, tu es obligé de réinitialiser l'Arduino pour rétablir la communication. Pour éviter cela il faut que le flag DTR soit à true. Regarde si c'est possible en VB6.

Le Flag DTR est déjà à True
11/08/2017, 15h21
slotizer

Citation:

Envoyé par Vincent PETIT

Salut,
Où as tu acheté ton Arduino UNO ?

Je trouve très surprenant que le PC ne voit plus l'Arduino (le port série virtuel). Je ne parle pas de la remarque de Auteur.

Je l'ai acheté à Paris dans une boutique électronique, cela n'est pas de l'ersatz chinois.

Le surprise est que cela fonctionne et puis d'un seul coup la connexion avec l'Arduino est perdue. je pense que c'est après la mise en marche des relais (après un certains nombre d'utilisation sans problème ?).
11/08/2017, 15h39
Delias

Citation:

Envoyé par slotizer

...et d'un seul coup la carte arduino n'est plus reconnue par le PC.

Peux-tu nous décrire exactement le symptôme vu depuis le PC. Quand la carte Arduino n'est plus reconnue:
- Est-ce que le port série est toujours présent dans Windows?
- Est-ce que la fermeture et la réouverture du port série depuis le programme en VB fonctionne (si non prévu l'arrêt puis le redémarrage du programme), ou y a-t-il une erreur?
- Est-ce que les ordres sont toujours envoyé du PC, ou y a-t-il une erreur (genre time-out)?

Si les réponses tendent vers un "le port série fonctionne toujours, il n'y a juste pas de réaction de l'Arduino" alors cela doit être un plantage du programme de l'Arduino (mais alors quoi :question:), si par contre c'est le port série qui bloque (genre j'ai des erreur de time-out dans le programme VB) c'est plutôt un problème de la passerelle USB-RS232, qui est indépendante.
Je penche bien pour le 1er. Alors que ta façon de le dire présage plus du 2ème cas.

En premier, il faudrait faire clignoter la Led par la boucle principale, pour vérifier que le prog n'est pas arrêté dans un coin quand la communication tombe

Delias
12/08/2017, 18h19
slotizer

Je vais refaire les tests. Il me semble que lors de la déconnexion, il faut débrancher et rebrancher l'USB. Le redémarrage de l'appli ne suffit pas.
Tes remarques me font penser aussi à faire un test avec autre PC plus récent, pour évacuer un problème hard.
12/08/2017, 20h43
Auteur

Citation:

Envoyé par slotizer

Il me semble que lors de la déconnexion, il faut débrancher et rebrancher l'USB. Le redémarrage de l'appli ne suffit pas.

c'est symptomatique d'une connexion qui n'est pas fermée correctement (pas de CLOSE COM ou équivalent en VB) d'où l'importance de mettre le flag DTR à true. Et dans ce cas effectivement le redémarrage de l'application ne suffit pas il faut aussi réinitialiser l'Arduino.

Désolé d'insister mais dans le code VB que tu as posté OPENCOM("COM" & Format(WCom, "0") & ",9600,N,8,1"), rien n'indique que DTR est effectivement à true.

Je te renvoie un code plus complet sur l'ouverture du port. VB envoie "T/" à l'arduino qui allume une led et renvoie "T" au VB

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
WRetour = OPENCOM("COM" & Format(WCom, "0") & ",9600,N,8,1")
If WRetour <> 0 Then
        BUFFERSIZE (1024)
        TXD 1
        RTS 1
        DTR 1
        DoEvents
        TimeHeure = GetTickCount / 1000
        Do While GetTickCount / 1000 < TimeHeure + 2
        Loop
        SENDBYTE Asc("T")
        SENDBYTE Asc("/")
 
'MsgBox (CTS * 100 + DSR * 10 + RI)
 
        TimeHeure = GetTickCount / 1000
        Do While GetTickCount / 1000 < TimeHeure + 4
            WP = READBYTE
            If WP <> -1 Then
                Select Case WP
                    Case Asc("T")
                        MemSerie = WCom
                        Exit Do
                    Case Asc("E")
                        MemSerie = 0
                        MsgBox ("Erreur de communication entre Arduino et PC")
                    Case Else
                        MsgBox ("Message inconnu ==> " + WP)
                        MemSerie = 0
                End Select
            Else
                MemSerie = 0
            End If
        Loop
        CLOSECOM
Else
    MemSerie = 0
End If
 
End Sub

Dans le déroulé du programme, je ne cherche pas à fermer le port com avant la fin de l'appli.

12/08/2017, 23h45
Delias

Tu ne réponds pas à ma question: Est-ce qu'il y a une erreur système sur le programme VB à l’exécution quand le problème arrive :question: Une erreur système c'est comme si tu démarres ton programme VB sans que l'Arduino soit branché, il y aura l'erreur "port com not found" ou quelque chose du genre.
Débrancher l'USB fait un Reset général provoquant aussi un redémarrage du programme Arduino.

Le DTR en s'en f... ,sur l'Arduino la connexion série est minimaliste, uniquement RXD et TXD sont implémentés. Les instructions concernant les autres lignes d'un port série sont simplement ignorées.

Si au lieu de débrancher le port USB tu fais un simple Reset au moyen du bouton poussoir, cela donne quoi? Si cela résous le problème c'est bien le programme Arduino qui plante (cas 2) et non la connexion série qui tombe.

Delias
13/08/2017, 10h00
Auteur

Citation:

Envoyé par Delias

Le DTR en s'en f... ,sur l'Arduino la connexion série est minimaliste, uniquement RXD et TXD sont implémentés. Les instructions concernant les autres lignes d'un port série sont simplement ignorées.

J'en rajoute une couche quitte à me prendre une série de :moinsser: ....
https://rheingoldheavy.com/arduino-f...dtr-and-reset/
https://startingelectronics.org/arti...2-differences/
Le signal DTR est lié au reset de l'Arduino.

Après, je conçois très bien que le problème ne vient pas forcément de là.

Est-il possible de créer un programme plus simple ? Avec VB6 :
- ouvrir le port COM ;
- envoyer un caractère à l'Arduino qui allumera une LED à sa réception puis renverra au programme VB6 le caractère en question.
- afficher le caractère envoyé par l'Arduino (si tout va bien il est identique à celui envoyé :aie:);
- fermer le port COM.
13/08/2017, 16h26
slotizer

Si tu lis le code VB6 que j'ai envoyé précédemment, tu verras que c'est exactement ce que je fais : envoi de "T/". A la réception par l'arduino une led s'allume 2 secondes et envoi au PC de "T". Cet échange correct permet de valider l'ouverture de la connexion.
Quant au rôle de DTR, le problème ne se pose pas car il est à 1.
13/08/2017, 16h37
slotizer

Citation:

Envoyé par Delias

Tu ne réponds pas à ma question: Est-ce qu'il y a une erreur système sur le programme VB à l’exécution quand le problème arrive :question: Une erreur système c'est comme si tu démarres ton programme VB sans que l'Arduino soit branché, il y aura l'erreur "port com not found" ou quelque chose du genre.
Débrancher l'USB fait un Reset général provoquant aussi un redémarrage du programme Arduino.

Le DTR en s'en f... ,sur l'Arduino la connexion série est minimaliste, uniquement RXD et TXD sont implémentés. Les instructions concernant les autres lignes d'un port série sont simplement ignorées.

Si au lieu de débrancher le port USB tu fais un simple Reset au moyen du bouton poussoir, cela donne quoi? Si cela résous le problème c'est bien le programme Arduino qui plante (cas 2) et non la connexion série qui tombe.

Delias

Je peux répondre à une partie de la question :D lorsque connexion lâche si je redémarre l'appli j'ai une erreur à l'opencom VB (pas analysée).
Je n'avais jamais utilisé le bouton reset, je vais faire le test et te dis quoi
15/08/2017, 15h37
slotizer

Je viens de réaliser le test : il se trouve que la déconnexion est arrivée lorsque 1 des 2 relais était fermé (par l'application) : il reste collé, la détection applicative ne fonctionne plus, mais ARduino essaie d'envoyer le message de détection normalement (j'ai une led qui s'allume à chaque détection de passage).
A la lecture de ce qui précède, il est évident que le reset ne sert à rien (comme tu me l'avais indiqué).
Il s'agit donc de ma liaison USB <==> Arduino qui ne fonctionne pas correctement.
Le seul truc (simple) à faire est de changer le PC (un vieux sous XP) par un plus récent sous W7, à moins qu'il existe une autre solution ...
En tout cas merci pour la méthodologie de recherche.
JF
15/08/2017, 15h47
Vincent PETIT
Changer de PC n'est peut être pas la bonne solution.
Donc des que les deux relais collent ça ne fonctionne plus.

Puisque tu sembles arriver à reproduire le problème :
- Est ce qu'il survient immédiatement après que les deux relais collent ? Ou un peu de temps après ? Est ce qu'il arrive que un seul relais fasse déconner le montage ?
- C'est quoi cette carte relais, tu as une référence ?
- Elle est alimentée comment et par quoi ?
- On peut voir une photo du prototype ?
15/08/2017, 17h39
slotizer

Non la déconnexion ne se produit pas lors de l'activation des 2 relais.
Elle se produit au bout d'un certain temps (non évaluable) d'utilisation simultanée de la fonction détection (IR) et la fonction relais, quelque soit le relai.
Après la déconnexion l'Arduino pilote très bien les relais et les IR mais d'un seul coup les ordres applicatifs ne lui arrivent plus (comme je le dis dans mon précédent message, la fonction détection marche car j'ai prévu des Led qui s'allument ...et elles s'allument).
Je n'ai pas la référence de la carte "module 2 Relais"
Le tout est alimenté par USB, j'ai essayé avec une alime annexe, le pb est identique
Je ferai un photo, mais le montage est si simple ....
17/08/2017, 19h39
slotizer

Je viens de réaliser des tests "en réel" (sur la piste de mon circuit dans le garage) avec mon portable qui me sert aussi de plateforme de développement.
Aucuns soucis tout a fonctionné à merveille pendant 2 heures sans soucis.

Donc le problème vient de la liaison série de mon vieux PC sous XP. N'y a-t'il rien à faire pour que ce "vieil" appareil ait un port Com qui fonctionne correctement ?

En tout cas, merci pour avoir circonscrit le problème.

JF
17/08/2017, 20h30
Auteur

C'est peut-être idiot mais :
- ton Arduino quand tu le branches sur ta machine XP, tu le branches sur un hub ou directement sur le port USB de la machine ?
- as-tu essayé un autre port USB ? Les ports USB sur un ordi fonctionnent rarement seuls, il vont généralement par 2 (après tu as sur la carte mère un contrôleur USB qui se charge de les faire travailler). L'idée est de savoir si le port USB en question fournit assez de courant à ta carte.
- tes drivers pour XP sont bien installés (https://www.arduino.cc/en/Guide/UnoDriversWindowsXP) ?

Je m'interrogeais aussi sur la vitesse de transfert, mais tu es déjà au minimum, à 9600 bauds (on va rarement en dessous).
25/08/2017, 19h22
Auteur

Citation:

Envoyé par slotizer

Pour évacuer les problèmes d'alimentation de la carte, j'ai ajouté une alime de 12V (Vieille alime de pc) avec un résultat identique.

je viens de repenser à une chose : pour certaines alimentations, il faut une charge minimale (une impédance minimale aux bornes de la sortie) pour qu'elles délivrent le courant voulu. Je crois que c'est le cas des alimentations PC. Si ton alimentation ne peut délivrer le courant nécessaire tu peux avoir des pertes de puissance.
As-tu essayé avec une alimentation de laboratoire ou quelque chose s'y rapprochant ?
26/08/2017, 10h52
slotizer

Merci, Je vais essayer avec une alime plus "traditionnelle".