Discussion :

[sone47]

Bonjour a tous,
Je viens poster ici pour avoir quelques avis sur un probleme rencontré:
J'ai une routine principale en C qui tourne sur un PC.
Ce PC est relié a une board.
J'ai deux fonctions deja implémentées:
void transmit(char *)
void receive(char *)
qui me permettent de communiquer entre mon soft pc et la board.
Mon soft pc me propose un menu (sous dos) avec divers choix(1 2 3 ou 4),
qui m'amene a des sous menus.
Certains choix permettent d'aller directement parametrer la board.

Lorsque je veux communiquer avec la board je suis obligé d'utiliser la syntaxe:
coté pc

Code :

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

1
2
3
choix = getchar();
getchar(); //ne pas transmettre ENTER
transmit(&choix);

et sur la board

Code :

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

1
2
 
char c = receive(&c);

Mon probleme maintenant est que je dois calculer au prealable a quel moment je vais envoyer un parametre de facon a placer au bon endroit de mon code les "transmit()" et "receive()", ce qui limite l'utilisateur.
Par exemple si un choix nous amene dans une routine un peu longue (ex lecture fichier) je suis obligé d'attendre la fn de cette routine pour pouvoir transmettre un nouveau parametre.
Quels conseils me donneriez vous pour pouvoir ne pas definir au prealable tous ces transmit() mais un seul ou une fonction qui puisse ainsi me permettre d'interrompre une tache?
Aussi ce meme principe pourrait permettre de ne plus calculer au prealable quand la board va nous renvoyer une data.
Est ce realisable?
Vos commentaires sont les bienvenus.
Merci davance

[Emmanuel Delahaye]

J'ai une routine principale en C qui tourne sur un PC.

Quel système ?

Ce PC est relié a une board.

Une carte électronique ? Avec un uart, quel genre de logiciel dessus ? C'est toi qui l'a écrit ?

J'ai deux fonctions deja implémentées:
void transmit(char *)
void receive(char *)

Qui tournent sur le PC et/ou sur la carte ? Ce sont des fonction de transfert de chaines de caractères ? Je ne vois pas bien comment peut fonctionner receive() sans indication de taille... Explosion en perspective...

qui me permettent de communiquer entre mon soft pc et la board.
Mon soft pc me propose un menu (sous dos) avec divers choix(1 2 3 ou 4),
qui m'amene a des sous menus.
Certains choix permettent d'aller directement parametrer la board.

Ton PC tourne sous DOS ? Bienvenu au moyen age...

Lorsque je veux communiquer avec la board je suis obligé d'utiliser la syntaxe:
coté pc

Code :

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

1
2
3
choix = getchar();
getchar(); //ne pas transmettre ENTER
transmit(&choix);

Ah, tu transmets les caractères un par un... ? Pourquoi char * et pas int ? OK, Je comprends mieux l'interface de receive()...

J'aurais fait :

Code :

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

1
2
     void transmit(int c) 
     void receive(char *pc)

ou

Code :

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

     int receive(void)

et sur la board

Code :

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

1
2
 
char c = receive(&c);

OK, c'est cohérent.

Mon probleme maintenant est que je dois calculer au prealable a quel moment je vais envoyer un parametre de facon a placer au bon endroit de mon code les "transmit()" et "receive()", ce qui limite l'utilisateur.

WTF ? Quels sont les besoins de dialogue de ton application PC avec la carte ?

Il faut faire les choses dans l'ordre. Il faut passer par une phase de définition sérieuse, puis par une conception qui fera apparaitre la manière d'organiser le code. Le codage ça vient après tout ça.

[sone47]

Merci d'avoir repondu.
Mon Pc ne tourne pas sous dos c'est juste une fenetre dos qui m'affiche un menu.
Les fonctions transmit et receive sont deja implementé. Bien sur il y en a deux de chaque, une qui transmet un caractere et une ou l'on peut definir une taille mais j'ai voulu faire simple pour l'explication et je ne me sert que de celle qui envoie 1 caractere.
Mon but n'est pas d'aller modifier le code sur la board pour l'instant je ne me penche que sur ma routine principale sur pc.
Je voudrai juste dans mon soft pc (sous win2000 buildé avec visual) n'avoir qu'une fonction pour la transmission independante.
C'est a dire qu' a n'importe quel moment je puisse lorsque j'appui sur un caractere l'envoyer directement (via transmit(char *)) sans attendre qu'une routine dans mon main se termine (l'interrompre).
Le meilleur serait meme que je n'ai pas a valider par entrer.
Je ne sais pas si on peut qualifier ceci d'interruption ni meme si c'est realisable.
Par la suite je m'interresserai a la board pour avoir ce meme systeme avec la reception.
Merci beaucoup d'avance.

[sone47]

Pour faire plus simple et concret,
J'ai mon main dans lequel s'execute plusieurs tache.
A un moment quelconque j'appui sur une touche clavier, ce qui me declenche une transmission (transmit(char *)) instantanement sans attendre que la routine qui etait en train de s'executer se termine.
Des que l'on est passé par cette fonction transmit(char *) on reprend notre routine que l'on avait interrompu.
J'ai pu voir la fonction kbhit() mais elle ne permet pas d'interrompre une tache.
Est ce realisable ?
merci

[cmoibal]

Pour faire plus simple et concret,
J'ai mon main dans lequel s'execute plusieurs tache.
A un moment quelconque j'appui sur une touche clavier, ce qui me declenche une transmission (transmit(char *)) instantanement sans attendre que la routine qui etait en train de s'executer se termine.
Des que l'on est passé par cette fonction transmit(char *) on reprend notre routine que l'on avait interrompu.
J'ai pu voir la fonction kbhit() mais elle ne permet pas d'interrompre une tache.
Est ce realisable ?
merci

Tu peut faire utiliser les thread par exemple? je pense qu'il suffit de lancer un thread qui fera le traitement ( sans interrompre l'exécution du main)

Ou plus encore, les signaux, tu déclenché une opération par les signaux juste ne envoyant le signale a votre process ?

mais tous ça reste à voire, il nous faut un bout de code pour qu'on puissent mieux t'aider.

[sone47]

Merci

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
 
int main (void)
{
  char choix;
  while(1)
  {
  printf("faire selection:\n");
  printf("lecture --> 0\n");
  printf("ecriture--> 1\n");
  choix = getchar();
  getchar();
  transmit(&choix);
  switch(choix)
  {
    case '0' : 
         printf("lecture carte...\n");
         //.... autres actions
    break;
    case '1' :
         printf("ecriture carte ...\n");
         //.... autres actions
    break;
    defaut : 
         printf("erreur saisie");
    break;
 
  }
  }
}

Voici actuellement ce que j'ai.
Maintenant le probleme: si je suis en train de lire dans le case 0, j'effectue toutes les autres actions. Si je veux ecrire je suis obligé d'attendre que je sorte du case 0 (donc de finir toutes mes procedure qu'il y a dedans) pour revenir au getchar initial.
Avec ce code ma saisi n'est possible qu'au debut de ma boucle while alors que j'aimerai pouvoir envoyer un caractere a n'importe quel moment.

[cmoibal]

Votre problème ce présente comme un accés a une resource partagé.

doonc, il suffit d'utiliser les THREAD pour chaque operation en parallele que tu veux ??????????????


un thread pour la lecture de la carte et un autre pour la saisie..... et voila le travail, et tu peut ce que tu veu le moment volu !!!!!

[sone47]

Pour poursuivre sur cette exemple:

J'ai entré 0 donc j'ai envoyé '0' sur ma board qui est en train de lire.
Dans mon case 0 je fais d'autres actions.

Puis tout a coup j'appui sur une touche ex: c, qui serait une option de lecture pour ma board (lire et convertir min en maj).
Ce 'c' ne serai envoyer qu'apres etre sorti du case 0, puis revenu au getchar initial.
J'aurais pu mettre un getchar dans mon case 0 mais je ne veux pas que le programme attende une entrée car celle ci peut ne jamiais arrivée.
J'aurais pu utilisé kbhit() mais ce dernier nous oblige a pensé au préalable ou et quand l'utilisateur serait susceptible d'entrer un caractere (et a ce moment la on test si oui ou non il l'a rentré).
Je ne sais pas si je me fais comprendre peut etre je part completement sur une fausse piste d'utilisation.

[sone47]

Merci beaucoup d'avoir répondu je vais me pencher dessus alors car je n'ai jamais utilisé les thread.

[sone47]

Merci je vais donc les utiliser je pense que ca repondra parfaitement a ce que je desire.
Une question parallele: peut on recuperer une entree clavier sans avoir a presser la touche entrer. En ayant acces au buffer d'entrée en verifiant si une data est arrivée par ex ?
Merci

[Emmanuel Delahaye]

Merci d'avoir repondu.
Mon Pc ne tourne pas sous dos c'est juste une fenetre dos qui m'affiche un menu.

Une fenêtre DOS, tu es sûr ? Quel est ton système ?

Les fonctions transmit et receive sont deja implementé. Bien sur il y en a deux de chaque, une qui transmet un caractere et une ou l'on peut definir une taille mais j'ai voulu faire simple pour l'explication et je ne me sert que de celle qui envoie 1 caractere.

OK.

Mon but n'est pas d'aller modifier le code sur la board pour l'instant je ne me penche que sur ma routine principale sur pc.
Je voudrai juste dans mon soft pc (sous win2000 buildé avec visual) n'avoir qu'une fonction pour la transmission independante.

Sous Win32, donc. Tu peux donc utiliser les threads pour rendre clavier, console, émission et réception indépendants.

http://emmanuel-delahaye.developpez.com/pthreads.htm

Après, c'est un problème de bonne conception.

Par la suite je m'interresserai a la board pour avoir ce meme systeme avec la reception.

Ca, par contre, ça va dépendre du système qu'il y a sur ta carte.

[Emmanuel Delahaye]

Une question parallele: peut on recuperer une entree clavier sans avoir a presser la touche entrer. En ayant acces au buffer d'entrée en verifiant si une data est arrivée par ex ?

C'est techniquement possible si tu utilises des bibliothèques comme CONIO ou PDCurses, mais si tu utilises les threads, c'est inutile. Il vaut mieux au contraire disposer des fonctions d'E/S standards qui sont bloquantes.

[sone47]

merci pour ces reponses.
Les fonctions bloquantes sont plus utiles car on peut tester la valeur recue du clavier avant de l'envoyer? Et ainsi ne pas envoyer une data erronée (faute de frappe)?
voici un bout de code a l'etat de conception (non testé).

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
 
#include <stdio.h>
#include <pthread.h>
#include "dlib.h"
 
void lecture_menu(void);
void ecriture_menu(void);
 
 
static void *thread_transmit (void *p_data)
{
   int ret=1;
   char c_t;
   while(1)
   {
      ret=kbhit();
      if (ret!=0) 
      {
           c_t=getch();
           transmit(&c);//fonction de dlib 
      }
   }
   return NULL;
}
 
static void *thread_receive (void *p_data)
{
   char c_r;
   while(1)
   {
      //reception
   }
   return NULL;
}
 
int main (void)
{
   // declaration 
   pthread_t ta;
   pthread_t tb;
   char choix;
   int ret_thread
   // presentation du menu
   printf("entrez choix\n");
   printf("lecture:0\n");
   printf("ecriture:1\n");
 
   choix = getchar();
   getchar();
   ret_thread=pthread_create (&ta, NULL, thread_transmit, NULL);
   if(ret_thread==0)
   {
      printf("tache de transmission créée\n");
      if(ret_thread==0)
      { 
         printf("tache de reception créée\n");    
         pthread_create (&tb, NULL, thread_receive, NULL);
      }
      else
      {
         printf("erreur tache de reception\n");
         exit(0);
      }
   else
   {
      printf("erreur tache de transmission\n");
      exit(0);      
   }
 
   while(1)
   {
      switch (choix)
      {
         case '0':printf("processus de lecture\n"):
                    lecture_menu();
         break;
         case '1':printf("processus d'écriture\n");
                    ecriture_menu();
         break;
         defaut:printf("mauvaise saisie\n");
         break;
      }
   } 
   pthread_cancel (ta);
   pthread_cancel (tb);  
}
void lecture_menu(void)
{
   char choix;
   printf("lancer lecture:1\n");
   printf("init lecture:2\n");
   printf("quitter lecture:3\n");
 
}
void ecriture_menu(void)
{
   printf("lancer ecriture:1\n");
   printf("init ecriture:2\n");
   printf("quitter ecriture:3\n");
}

Ce code n'est pas testé mais ca permet de situer vers ou je vais.
Ce que je n'arrive pas a comprendre, c'est comment passer de l'execution type1(actuelle) a l'execution type 2 definies dessous :

-------- type 1 ------------------------
--j'affiche le menu principal avec les choix
--je recupere data (getchar)
--je lance mes deux threads
--je recupere les data grace au thread de transmission

-------- type 2 ------------------------
--j'affiche le menu principal avec les choix
--je lance mes deux threads
--je recupere les data grace au thread de transmission
--> ces memes datas me permettent de me balader dans des sous menus du main


en realité, chaque data que je vais saisir sera envoyée sur la board via transmit mais elle doit aussi me permettre de me balader dans mon main de facon a afficher via des printf les divers choix possibles selon les entrées.

Mon main me permet juste de faire 'l'interface' visuelle entre la board et l'utilisateur (afficher juste des choix et l'état actuel par ex).

Dois je definir dans thread_transmit la variable c_t en globale?

Pour la reception je pensais faire un thread_receive dans le meme style que le transmit en testant des qu'une data arrive sur le port serie mais bon c'est pour la suite.

Merci encore

[Emmanuel Delahaye]

Les fonctions bloquantes sont plus utiles car on peut tester la valeur recue du clavier avant de l'envoyer? Et ainsi ne pas envoyer une data erronée (faute de frappe)?

Rien n'empêche de tester la donnée après la saisie :

Code :

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

1
2
3
4
5
 
FAIRE
 donnee := saisir()
TANT QUE NON est_valide (donnee)
traiter (donnee)

On peut se lancer dans le luxe non portable qui consiste à tester les caractères au moment de la saisie, mais est-ce bien utile ?

-------- type 2 ------------------------
--j'affiche le menu principal avec les choix
--je lance mes deux threads
--je recupere les data grace au thread de transmission
--> ces memes datas me permettent de me balader dans des sous menus du main

J'ai peur de ne pas comprendre.

• Quelle est l'application finale que tu veux réaliser ?
• Quelle est le rôle de la carte ? (board)
• Quel est le rôle du PC ?
• Si il y a un échange de données spécifié entre la carte et le PC, quel est-il ?
• Si il y a une interface homme/machine (IHM) spécifiée entre l'application (PC+carte) et l'utilisateur, quelle est-elle ?

Il me faut une réponse précise à ces questions avant d'aller plus loin, car j'ai cru détecter un grave problème de conception.

[sone47]

bonjour,
l'utilisation que je compte en faire est :
le soft sur le pc permet d'afficher des choix sur des actions que l'on peut faire sur la board.
lorsque un choix est effectué, la donnée saisie est envoyée a la board (transmit()), qui fait son traitement ou attend une nouvelle donnée (sous menu), sur le pc il faut donc afficher ces sous menus pour que l'utilisateur puisse savoir les possibilités qu'il a.
Le but du soft sur le pc (pour l'instant) est de pouvoir afficher toutes les possibiités qu'a l'utilisateur (menu) pour ne pas etre perdu au bout de plusieur saisies.
Les datas saisies sont donc utilisées :
par le soft pc pour afficher les menus.
par un processus parallele pour envoyer a la board.

Le cas concret est que si l'utilisateur decide d'envoyer une commande lecture a la board, celle ci est envoyé et sur le pc on affiche d'autre choix(init lecture, stop lecture), l'utilisateur peut laisser la carte faire sa lecture, mais peut aussi vouloir la stopper prematurément, donc en imaginant qu'il y a une multitude de choix et de sous choix, je voulais trouver un moyen de ne pas avoir a prevoir quand l'utilisateur serait susceptible d'envoyer une data.
merci

[Emmanuel Delahaye]

l'utilisation que je compte en faire est :
le soft sur le pc permet d'afficher des choix sur des actions que l'on peut faire sur la board.
lorsque un choix est effectué, la donnée saisie est envoyée a la board (transmit()), qui fait son traitement ou attend une nouvelle donnée (sous menu), sur le pc il faut donc afficher ces sous menus pour que l'utilisateur puisse savoir les possibilités qu'il a.
Le but du soft sur le pc (pour l'instant) est de pouvoir afficher toutes les possibiités qu'a l'utilisateur (menu) pour ne pas etre perdu au bout de plusieur saisies.

C'est donc un 'menu déporté'... complexe...

Les datas saisies sont donc utilisées :
par le soft pc pour afficher les menus.
par un processus parallele pour envoyer a la board.

Pas forcément. Il paut y avoir interprétation. Il faut en principe décoreler l'IHM du dialogue PC/Carte. Je crois que c'est ce point précis que tu n'as pas saisi...

Le cas concret est que si l'utilisateur decide d'envoyer une commande lecture a la board, celle ci est envoyé et sur le pc on affiche d'autre choix(init lecture, stop lecture), l'utilisateur peut laisser la carte faire sa lecture, mais peut aussi vouloir la stopper prematurément, donc en imaginant qu'il y a une multitude de choix et de sous choix, je voulais trouver un moyen de ne pas avoir a prevoir quand l'utilisateur serait susceptible d'envoyer une data.

Simple question de protocole. Si tu veux un menu déporté, il faut prévoir quelles sont les commandes du PC et les réponses de la carte. Il peut y avoir des messages qui interrompent une action en cours.

La question plus générale est de savoir si c'est à la carte d'embarquer le menu ou non. Si c'est le cas, la carte se comporte un peu comme un 'serveur', sur laquelle on branche un terminal (hyperterminal etc.). Il n'y a alors plus aucun développement à faire sur le PC, mais tout est à faire sur la carte. Problème, ça peut représenter un code important sur la carte et un volume de données carte-> PC relativement important (les écrans des menus etc.).

La solution que tu préconises consiste à définir un jeu de commandes sur la carte (c'est elle qui contient l'interpréteur de commande qui peut être assez simple) et de construire une IHM sur le PC (menu 'local'), qui se contente de passer des commandes et d'interpréter les résultats. Ca peu vite être assez complexe, surtout si il faut gérer une base de données locale qui contient une 'image' de la configuration courante de la carte...

Ces choix sons exclusifs et plutôt définitifs, alors il ne faut pas se tromper. pour décider en connaissance de cause, il faut connaitre précisément les fonctions de la carte que l'on peut activer à distance.

[sone47]

Bonjour,
le menu doit etre sur le pc.
Pourquoi dois je me soucié de la carte si le but est d'envoyer n'importe quand une commande et d'afficher les menus correspondant. C'est uniquement le soft pc qui doit gerer tout ca.
Quand vous parliez de grave probleme de conception, qu' est il?
Merci

[Emmanuel Delahaye]

le menu doit etre sur le pc.
Pourquoi dois je me souciéer de la carte si le but est d'envoyer n'importe quand une commande et d'afficher les menus correspondant. C'est uniquement le soft pc qui doit gerer tout ca.
Quand vous parliez de grave probleme de conception, qu'est il ?

La carte en question est bien une carte 'active' avec un processeur et un programme spécifique ? Ou bien est-ce une carte 'passive', genre carte d'extension du PC ? (genre PCI...)

[sone47]

Oui la carte est active, elle a son propre mcu et son code embarqué, elle attend juste les datas saisies pour faire ses executions.

[Emmanuel Delahaye]

Oui la carte est active, elle a son propre mcu et son code embarqué, elle attend juste les datas saisies pour faire ses executions.

OK. Ces donnés sont transmises comment ? En série ?

Code :

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

1
2
3
4
5
6
 
 ------                  ---------
|PC   tx|-------------> |rx carte |
|     rx|<------------- |tx       |
|    gnd| ------------- |gnd      |
 -------                 ---------