Discussion :

[photo2bob]

Bonjour, nouveau sur ce forum, j’espère exposer mon problème au bon endroit.

Avec une carte UNO , je commande trois ecletrovannes et un appareil photo pour faire des photos de collision de gouttes d'eau.
Mon programme consiste a ouvrir et fermer les electrovannes, soit simultanement ou avec un delais plus ou moins important entre chaque ouverture.
Le temps d'ouverture d'une vanne est de l'ordre de 15 millisecondes.
le scenarion classique:
a T0 ouverture V1 150ms
a T0 + 500ms ( T1) V2 150ms
a T0 + 1000ms (T2) V3 150ms
a T0 + 2000ms (T3) APN 180ms

J'ai besoin de faire varier T1, T2 et T3
Le probleme
Quand T1 < 200 ms les vannes V1 et V2 se déclenchent simultanément
De plus le systeme n'est pas stable, il est répétable un fois sur deux, quelque soit le nombre de vannes sollicitées.

Au niveau programmation, j'envoi a l' ARDUINO une sequence de commande Vanne,Delais
ex: V1,0:V2,T1:V3,T3:APN,T4
V1 est sur la pine 8 , V2 pine 9 , V3 pine 10 , APN pine 11 ( pine 0,1,2,3 du port B)

J'ai besoin d'une précision au dixième de milliseconde.
Je n'utilise pas la fonction delay(), a partir d'un T0 je compte les microsecondes
Je boucle sur toutes commandes V,T
et je déclenche les vannes quand leur T est supérieur ou égal au compteur.

Comme l'ouverture et fermeture des vannes peuvent être simultanées, j'initialise directement le port B avec les états des vannes.

Apparemment le PORTB ne commute pas assez vite quant l'ouverture de deux vannes se fait dans un delais "rapide"

En esperant que mes explications soient assez claires
je n'arrive pas a savoir si les problemes proviennent du programme, de la carte UNO ou de l'interface de commande des vannes
problemes de repetabilite et de commutation du portB
robert.

[Delias]

L'Arduino Uno est monté avec un quartz de 16MHz, donc la précision maximale théorique c'est 1/16^ème de µs. Mais cela c'est à condition de le programmer en C ou en ASM.
Après avec la surcouche Arduino on doit quand même rester dans l'ordre de grandeur de la microseconde, bien suffisant pour toi.

As-tu un oscillo branché sur les sorties de l'Arduino pour être certain que ce n'est pas la partie commande des électrovannes qui pose problème? Ou bien c'est le code, merci de le poster.
Est-ce que tu lis bien toute la trame d'ordre avant d'envoyer les ordres? Car la lecture du port série peut bien distorde le temps.

Delias

[Auteur]

bonsoir,

comme l'a indiqué Delias, en plus du code, peux-tu poster un schéma de ton électronique ? Tu n'as pas oublié la diode de roue libre aux bornes des électrovannes, par exemple ?

Peux-tu aussi nous donner les références des électrovannes ? Car ces composants ont aussi une partie mécanique : quand tu envoies ton impulsion l'ouverture n'est pas immédiate, il y a toujours un petit délai (temps de latence).
Pour plus de précision dans tes timing tu peux te tourner vers la bibliothèque elapsedMillis.

[photo2bob]

Merci pour vos reponses
Comment faire pour poster le code?

Fichier zippé ?

je prepare un schema de mon montage
robert

[photo2bob]

Le schema

[Delias]

Bonjour

Le schéma semble correct, manque éventuellement un condensateur entre le 12V et la masse au niveau des transistors TIP102. Mais son absence ne produirait pas tes problèmes.
Pour poster le code, il faut le copier-coller dans l'éditeur du forum (comme du simple texte) et l'encadrer avec la balise code (bouton "#") de la barre d'outils. Voir ICI.
Et n’hésite pas à prévisualisé ton message au moyen du bouton prévu!

Delias

[photo2bob]

J'ai modifié mon code pour utiliser la bibliothèque elapsedMillis.
Pas eu le temps de tester a fond.
Un premier test sur un scenario classique marche.

Je posterai le code ulterieurement.
merci
robert

[Auteur]

Dans la doc technique je n'ai pas trouvé les temps de latence. Une ouverture de 15ms ça me semble bien court pour ce genre de modèle (je ne dis pas que c'est impossible ).

[photo2bob]

Bonjour,
on m'a prêté un ocsillo, pas de dernière génération, mémoire par rémanence de l’écran.
J'ai quand même vérifier que la commutation du portB est correcte. j'en déduit que c'est l'interface de puissance qui pose problème.

Delias,
tu fais reference a un condensateur entre "le 12V et la masse au niveau des transistors TIP102"
Quelle est la valeur des condensateurs, je suppose qu'il en faut un par transistor
Est ce que la qualité des diodes peut jouer aussi, sur la stabilité du systeme.
C'est vrai que si j'attend un "certain temps" la répétabilité s’améliore.

Voulez vous que poste quand même mon code ?
Merci

[Auteur]

bonsoir,

le condensateur sert à lisser la tension d'alimentation, 1 seul suffit et un condo chimique de 10µF est suffisant.

Allonge tes durées d'ouverture de tes électrovannes. Elles doivent faire un "clac" assez bruyant pour l'ouverture et un autre plus faible lors de la fermeture.

Le transistor est un Darlington avec des résistances et une diode. Tu n'as pas autre chose ?

[Delias]

Bonsoir

Le ou les condensateurs sont à monter, pour le + sur le point le plus proche de l'alimentation + des 3 électrovannes (là où il devrait avoir quatre fils: 1 depuis l'alim et 3 vers les 3 vannes), pour le - sur le point le plus proche des 3 émetteurs des TIP.
La ou les valeurs dépendent du courant des électrovannes, éventuellement un céramique de 100n ou plus et un électrolytique de 10u, 100u, 470u.

Il faudrait également éviter de faire transiter le courant du - des électrovannes par la carte Arduino et le prendre comme pour le plus sur la sortie de l'alimentation à découpage.

Le TIP va très bien, comme tout Darlington il perd un peu de tension, pour 12V à l'alim, il devrait y avoir 10V à 11V aux vannes c'est suffisant, mais peut être une cause d'ouverture légèrement plus lente des vannes. Pour les diodes de roues libres, avec un TIP de simple diode de redressement silicium, d'un courant nominal proche de celui des électrovannes.

Delias

[photo2bob]

Delias
>> Il faudrait également éviter de faire transiter le courant du - des électrovannes par la carte Arduino et le prendre comme pour le plus sur la sortie de l'alimentation à découpage.

J'ai refais l'alimentation des vanes et rajouter un condensateur de 10µ en tenant compte de tes remarques.
J'ai toujours le meme probleme.
Est ce que les transistors ne devraient pas etre tres proches des electrovannes. Mes transistors sont monté sur une plaque vient au dessus de l'arduino. Du coup j'ai une longueur de fil plus importante avec les EV

Bon pour l'instant que je range tout ca, mais je ne laisse pas tomber.

je poste le code, on sait jamais


gouutes_let_V8.ino

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
#include <elapsedMillis.h>
#include "cmd.h"
#include "data.h"
 
#define VALVE_NUMBERS      5
short int  VALVE[VALVE_NUMBERS] = { 
     0 , 8 , 9 , 10 , 11 } 
;
 
int loggingLevel = DEBUG;
 
String inputString = "";         // a string to hold incoming data
boolean stringComplete = false;  // whether the string is complete
 
void setup() {
  Serial.begin(115200);
  inputString.reserve(1024);
  DDRB = B00111111  ;
  PORTB = B00000000 ;
}
 
int count = 0;
char input[MAX_INPUT_SIZE];
 
void loop() {
  while (Serial.available() ) {
     char inChar = (char) Serial.read(); 
     input[count] = inChar;
     count++;
      if (inChar == '\n') {
          stringComplete = true ;
          input[count - 1 ] = '\0';
          processCommand(input);
          count = 0;
      }
    } 
}
 
void logging(const int level, const char* message) {
  //if(level <= loggingLevel) {
    Serial.println(message);
  //}
}

CMD.H

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
 
/*
 * cmd.h
 *
 * Created: 12/12/2015 12:17:16
 *  Author: robert
 */ 
 
#define FIELD_SEPARATOR   ";"
 
#ifndef CMD_H_
#define CMD_H_
 
// logging message levels
#define ERROR 0
#define WARN 1
#define INFO 2
#define DEBUG 3
 
// commands
#define CMD_RUN         "R"
#define CMD_IR_start    "D"
#define CMD_IR_stop     "B"
#define CMD_SUBMIT      "S"
#define CMD_LOAD        "L"
#define CMD_OPEN        "O"
#define CMD_CLOSE       "C"
#define CMD_TEST        "T"
 
#define MAX_INPUT_SIZE     512
 
void processCommand(char* cmd);
void processOpenClose(int mode);
void processStartStop_A_IR(int mode);
void processSubmit();
void processRunCommand();
void execRunCommand();
void logging(const int level, const char* message) ;
void processLoadData() ;
 
#endif /* CMD_H_ */

Module de gestion des commandes
CMD.CPP

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
98
99
100
101
102
103
104
105
106
107
108
109
 
 
#include <Arduino.h>
 
#include "cmd.h"
 
extern short int VALVE[] ;
 
 
void processCommand(char*  cmd) {
 
 
char* cmdToken = strtok(cmd, FIELD_SEPARATOR);
 
  int i ;
 
  if (strcmp(cmdToken, CMD_RUN) == 0) {
    logging(DEBUG, "received run command");
    processRunCommand();
  }
  else if (strcmp(cmdToken, CMD_SUBMIT) == 0) {
    logging(DEBUG, "received SUBMIT command");
    processLoadData();
    processRunCommand();
  }
  else if (strcmp(cmdToken, CMD_OPEN) == 0) {
    //logging(DEBUG, "received OPEN valve command");
    processOpenClose(HIGH) ;
  }
  else if (strcmp(cmdToken, CMD_CLOSE) == 0) {
    // logging(DEBUG, "received CLOSE valvecommand");
    processOpenClose(LOW) ;
 
  }
  else if (strcmp(cmdToken, CMD_LOAD) == 0) {
    // logging(DEBUG, "received LOAD data command");
    processLoadData();
  }
  else if (strcmp(cmdToken, CMD_TEST) == 0) {
    logging(DEBUG, "received TEST data command");
    Serial.println("debut TEST"); 
    PORTB = 0 ;
    delay(3000) ;
    PORTB = 1 ;
    delay(500) ;
    PORTB = 0 ;
    delay(3000) ;
 
    PORTB = 2 ;
    delay(500) ;
    PORTB = 0 ;
    delay(3000) ;
 
    PORTB = 3 ;
    delay(500) ;
    PORTB = 0 ;
    delay(3000) ;
    PORTB = 4 ;
    delay(500) ;
    PORTB = 0 ;
    delay(3000) ;
    PORTB = 5 ;
    delay(500) ;
    PORTB = 0 ;
    delay(3000) ;
    PORTB = 6 ;
    delay(500) ;
    PORTB = 0 ;
    delay(3000) ;
    PORTB = 7 ;
    delay(500) ;
    PORTB = 0 ;
 
 // Serial.println("Fin TEST");     
  }
  else {
    logging(WARN, "Command not found");
  }
}
 
 
void  processRunCommand() {
  execRunCommand() ;
}
 
 
void processSubmit() {
  processLoadData();
  delay(500) ;
  execRunCommand() ;
}
 
void processOpenClose(int mode) {
 
  char Num ;
  if (sscanf(strtok(NULL, "\n"), "%d", &Num) < 1) {
    logging(ERROR, "Wrong Format");
    return;
  }
 
  // check device number bounds
  if (Num < 1 || Num > 3 ) {
    logging(WARN, "wrong valve number");
    return;
  }
 
  logging(DEBUG, " valvecommand VALVE[Num], mode  ");
  digitalWrite(VALVE[Num], mode);
}

DATA.H

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
 
 
/*
 * data.h
 *
 * Created: 12/12/2015 12:30:40
 *  Author: robert
 */ 
 
#ifndef DATA_H_
#define DATA_H_
 
typedef  struct SDATA {
  unsigned long   Wait ;
           char   Valve ;
  SDATA    *suivi ;
}  ;
 
int freeRam () ;
void printdata () ;
void processLoadData() ;
void cleanData() ;
void execRunCommand() ;
 
#endif /* DATA_H_ */

Pour la gestion des DATA et execution
DATA.CPP

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
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
 
#include <Arduino.h>
#include "data.h"
#include "cmd.h"
#include <elapsedMillis.h>
 
SDATA *pDeb  ;  // pointer sur premiere Data
 
/*
 * debug procedure pour aafichier la RAM dispo
 */
int freeRam ()
{
  extern int __heap_start, *__brkval;
  int v;
  return (int) &v - (__brkval == 0 ? (int) &__heap_start : (int) __brkval);
}
 
/*
  initilise une liste chainée des  DATA
*/
 
/* 
schema classique
Les DELAIS sont données en 1/10 de ms 
 
L;4;1;0^0;185^2;200^0;300^
L --> commande LOAD
4 --> nombre de date set
1;0  --> premiere data , la valve 1 open sans delais
^
0;185 --> toutes les vannes fermées apres 185 ms
^
2;200 --> apres 1,5 ms, ouverture de la vanne 2
^
0;300 --> apre 10,0ms, fermeture de la vanne 
^
 
schema moins classique
L;8;1;0^3;100^7;110^6;185^4;200^0;230^8;1500^0;3300^
 
1;0
a T0        ouverture  vanne 1 pour 185ms PORTB = 1
 
3;100
a T0 + 10,0 ms  ouverture   vane 2  pour 10,0ms  ( V1 et V2 ouvert ) PORTB = 3
 
7;110
a T0 + 11,0 ms  ouverture vanne 3 pour 12,0ms  ( V1 V2 V3 ouverts ) PORTB = 7
 
6;185
a T0 + 18,5 ms fermeture vanne 1  ( V2 V3 ouvert ) PORTB = 6
  
4;200
a T0 + 20,0 ms fermeture vanne 2 ( V3 ouvert ) PORTB = 4
 
0;230
a T0 + 23,0 ms fermeture vanne 3 PORTB = 0
 
8;1500
a T0 + 150,0 ms ouverture APN, PORTB = 8
 
0;3300
a T0 + 330,0 ms Fermeture APN PORTB = 0
*/
 
/*
 * Les data sont chargées dans un liste chainée de pointer SDATA
  typedef  struct SDATA {
  unsigned long   Wait ;  --> delais pour changer l'etat du PORTB
           char   Valve ; --> etat du PORTB apres le delais 
  SDATA    *suivi ;
}  ;
*/
void processLoadData() {
  short    int  i     ;
  unsigned int  iValve ;
  unsigned long iWait ;
  char  N ; // nombre des item de la liste SDATA
 
  SDATA *data ;
  SDATA *pBck  ;  // pointer de backup d'une Data
 
  if (pDeb != NULL) cleanData() ;
 
  pDeb = NULL ;
  pBck = NULL ;
 
  // recuperation du nombre de DATA a traiter
  if (sscanf(strtok(NULL, FIELD_SEPARATOR), "%d", &N ) < 1) {
    logging(ERROR, "load Wrong Format");
    return;
  }
 
  // chargement de la liste chainée
  for ( i = 0; i < N ; i++) {
    iWait = 0 ;
    iValve = 0 ;
 
    sscanf( strtok(NULL,  "^" ), "%d;%d",  &iValve, &iWait)  ;
 
    data = (SDATA *) malloc(sizeof(struct SDATA )) ;
    if ( data == 0 ) {
      logging(DEBUG, "erreur memoire");
    }
    // les valeur DELAIS sont passées en 0,1 mS == 100 µS
    // on les multiple par 100 les avoir en µS
    // precision du compteur superMicros
    data->Wait  =  iWait * 100  ;  /* precision 1/10 de ms */
    data->Valve =   iValve   ;
    data->suivi = NULL   ;
 
    if (pBck == NULL ) {
      pDeb  = data ;
      pBck = data ;
    }
    else {
      pBck->suivi = data ;
      pBck  = data ;
    }
  }
  // logging(DEBUG, "fin de load");
  // printdata () ;
}
 
 
/*
 * petite procedure pour verifier le bon chargement des datas
 */
void printdata () {
  SDATA *pdata = pDeb;
  char buffer[100];
  while ( pdata != NULL) {
      buffer[0] = '\0' ;
      Serial.println("-------------");
      sprintf(buffer, "v:%d : %lu ", pdata->Valve, pdata->Wait );
      Serial.println(buffer);
      Serial.println("-------------");
      pdata = pdata->suivi ;
  }
}
 
 
 
void cleanData () {
  SDATA *data = pDeb;
  while ( data != NULL) {
    SDATA *next = data->suivi ;
    free(data) ;
    data = next ;
  }
  pDeb = NULL ;
  Serial.print("Free memory: ");
  Serial.println(freeRam() );
}
 
/*
 * on parcours la liste des data SDATA
 * pour chaque item on attend les delais data->Wait  pour initialiser le PPORTB avec data->Valve
 */
void execRunCommand() {
   SDATA *data = pDeb;
 
   volatile  uint8_t _valve ;
  // arret de toutes les vannes
  //PORTB = PORTB & B11110000;
  //PORTB = 240 ;
    PORTB = 0 ;
 
  elapsedMicros waiting ;
  // data = pDeb;
  waiting = 0 ;
 
  while ( data != NULL) {
 
    while ( waiting  < data->Wait ) { }
   // PORTB = data->Valve ;
   /*
    *  test avec une intruction code machine, pas concluant 
    */
    _valve = data->Valve ; 
    asm volatile( "out %1, %0" "\n\t" : : "r"(_valve) ,  "I" (_SFR_IO_ADDR(PORTB)));
 
    waiting = data->Wait  ;
    data = data->suivi ;
  }
}

Robert

[Vincent PETIT]

Salut Robert,
Ça risque de ne pas être simple a débugger car tu es aller trop loin dans le logiciel. Il va falloir que tu fasses un logiciel de test fonctionnel et minimaliste donc avec le stricte minimum nécessaire pour activer les relais comme tu le souhaites.
Retire tout ce que tu peux

• Pas de lecture de données arrivant de l'USB
• Pas de test mémoire
• Pas de vérification des datas (elles doivent être en dur dans le code)
• Pas d'affichage superflue
• ...
• ...
• ...

Il ne doit rester que quelques lignes mettant en évidence ou pas le problème. Si le problème n'est pas mis en évidence (donc problème de soft) alors il faudra ajouter le reste du programme morceau par morceau jusqu'à trouver le truc qui fait que ça déconne.

[photo2bob]

Merci

je fais suivre tes conseils.

robert