Discussion :

[abbc1811]

Bonjour à tous,

J'effectue actuellement mon stage de fin d'étude, mon projet de stage consiste à automatiser un essai.

Le programme que je dois effectuer doit-être capable de lancer plusieurs essais en parallèles ou en différés.
Lors de l'essai ce programme doit pouvoir piloter des électrovannes et effectuer une ou plusieurs acquisitions de données.

Afin de pouvoir lancer des essais en différés, j’envisageais d'utiliser des Timers (interruptions), comme lorsque l'on programme des systèmes embarquées, afin d'effectuer mon acquisition de données.
Ainsi je pourrais effectuer l'acquisition de données de chaque essais (si l'essai et actif grâce à des if) à une fréquence donnée et piloter mes électrovannes en fonction du temps écouler depuis le lancement de l'essai en question.
Ensuite dans le Main je mettrais une boucle infinie en demandant si l'on veut lancer un autre essai et activerais ainsi un autre essai.

Malheuresement je n'arrives pas a trouver (si il existe) un équivalent au Timers pour les microcontrôleur en c++.
Auriez-vous des conseils concernant mon problèmes ou des alternatives à me proposer ?

Je programme sous LabWindows/CVI mais si nécessaire je peux changer de logiciel.

Merci d'avance pour votre aide,
Cordialement,

[Iradrille]

Hello,

Tu penses à mon avis trop bas niveau.

Lancement des tests séquentiel

Code :

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

1
2
3
for(int i=0; i<NB_TESTS; ++i) {
    test(i);
}

Le lancement en parallèle (avec TBB ou OpenML par exemple) sera très proche : un #pragma à rajouter avec OpenMP, probablement un simple parallel_for avec TBB.

Le lancement en différé est tout aussi simple

Code :

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

1
2
3
4
5
6
// lancers tous les tests après un délais de 3 sec
std::this_thread::sleep_for(std::chono::seconds(3));
 
for(int i=0; i<NB_TESTS; ++i) {
    test(i);
}

Pour les timers, tu peux regarder du coté de std::chrono et de std::this_thread_sleep_for.

Si tu veux appeler un callback après x secondes, quelque chose du genre peut suffire

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
template <class Callback>
std::thread callAfterXSec(int sec, const Callback& cb) {
   return std::thread([sec, cb] () {
      std::this_thread::sleep_for(std::chrono::seconds(sec));
      cb();
   });
}
 
// lancer le test 1 après 5 sec, le test 2 après 10 sec
auto t1 = std::move(callAfterXSec(5, []() { test(1); }));
auto t2 = std::move(callAfterXSec(10, []() { test(2); }));
 
t1.join();
t2.join();

[abbc1811]

Merci pour avoir répondu aussi vite,

Par "différé" je voulais dire lorsque l'utilisateur le souhaite et non pas à une fréquence donnée.
Par exemple il faudrait pouvoir lancer une première pièce, en monter une deuxième la lancer, aller boire un café et monter une troisième et la lancer.

La raison pour laquelle je voulais utiliser des interruptions est que le temps d'essai dépends de la pièce que l'on teste et donc il faut demander à l'utilisateur qu'elle type de pièce il veut lancer (afin d'en déduire les temps d'essai) et du coup le scanf stop tout le programme et l'essai par la même occasion.
Tandis que si l'on utilise des interruptions (du moins si elles existent) al'acquisition et le pilotage des électrovannes des essais en cours ne sera pas perturbé par le scanf, du moins je l'espère.

Merci d'avance

[Iradrille]

Tandis que si l'on utilise des interruptions (du moins si elles existent) al'acquisition et le pilotage des électrovannes des essais en cours ne sera pas perturbé par le scanf, du moins je l'espère.

Encore une fois, tu penses trop bas niveau, à moins que tu bosses sur de l'embarqué, il n'y à pas de raison d'aller s'embêter avec les interruptions.
Les threads permettent d'exécuter du code en parallèle.

En utilisant un thread différent pour lire le clavier (plutôt std::cin que scanf d'ailleurs ) et pour effectuer les tests, std::cin ne bloquera pas les tests. Par exemple

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
std::vector<std::thread> threads;
 
while(1) {
	std::string str;
 
	// on entre un num de piece
	std::getline(std::cin, str);
 
	// si rien d'entré, on stop
	if(str.empty()) break;
 
	// on converti le string entré en int
	int n;
	std::stringstream ss;
	ss << str;
	ss >> n;
 
	// on lance le test dans un nouveau thread
	// (on peut aussi ajouter le test à une file d'attente
	// pour qu'il soit traité par une threadpool, et
	// éviter d'avoir trop de threads en parallele)
	threads.emplace_back([n]() { test(n); });
}
 
// on attend la fin des tests en cours
for(auto& t: threads) {
	t.join();
}

Si tu as besoin d'envoyer des données pendant les tests (exemple : une électrovanne fait n'importe quoi et tu veux pouvoir l’arrêter d'urgence depuis le soft de test), tu peux utiliser la même technique.
Il suffit de parser ce que l'utilisateur saisi et d'agir en conséquence. Par exemple

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
struct Vanne {
	explicit Vanne(int nb);
	void start();
	void stop();
	void join();
}
 
std::vector<Vanne> vannes;
 
while(1) {
	std::string str, cmd;
 
	// on entre un num de piece
	std::getline(std::cin, str);
 
	// si rien d'entré, on stop
	if(str.empty()) break;	
 
	// on parse le string entré (de la forme start/stop n° de Vanne)
	int n;
	std::stringstream ss;
	ss << str;
	ss >> cmd >> n;
 
	if(cmd == "start") {
		// on ajoute et démarre un test
		vannes.emplace_back(n);
		vannes.back().start();
	}
	else if(cmd == "stop") {
		// on stop un test s'il existe
		auto it=std::find(vannes.begin(), vannes.end(), n);
		if(it != vannes.end()) {
			*it.stop();
		}
	}
}
 
// on attend la fin des tests en cours
for(auto& v: vannes) {
	v.join();
}

[abbc1811]

D'accord je vais me pencher sur les threads du coup !
Merci pour votre aide

[white_tentacle]

Après, sur un microcontrôleur, ça peut être trop lourd les threads.

Dans ce cas, il doit y avoir des mécanismes pour attendre sur plusieurs file descriptors différents (type select / epoll / etc).