Discussion :

[coax81]

bonjours ,

dans mon projet je doit faire une lecture d'une donnée en continu lorsque j'appuie sur le bouton START . mais cela en arriere plan sans ploquer l'interface ...

pour l'instant l'ai reussi a faire un callback sur le bouton START , et lancer une boucle infini pour la lecture de la donnée , mais le problème c'est tout est bloqué apres ...

comment dois je faire pour faire en temps réel une lecture de la donnée en continu , et continuer a travailler sur autre chose en meme temps ?!


merci a tous

[Franck.H]

Cela coule de source pourtant, il te faut utiliser les Threads, tu as une implémentation portable dans la GLIB:
http://developer.gnome.org/doc/API/2...b-Threads.html
et un bon cours sur les Threads POSIX ici:
http://emmanuel-delahaye.developpez.com/pthreads.htm

[coax81]

je prefere poser la question maintenant , ceci est valable aussi pour un développement sous windows ?
comme ca je me lance dans la lecture ...

[Franck.H]

je prefere poser la question maintenant , ceci est valable aussi pour un développement sous windows ?
comme ca je me lance dans la lecture ...

Par rapport au cours, si tu utilise Pthread oui, c'est POSIX.1 donc portable. Par rapport à GLIB, cela ne change pas des masses, il suffit de faire l'adaptation par rapport à ses propres fonctions c'est tout !

[coax81]

merci Franck.H

[coax81]

bonjours ,


j'ai crée un thread qui fait une lecture d'un registre en boucle infini , j'ai utilisé la fonction :

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
 
 void *alert (gpointer *data)
{
 
    int i;
    int val;
    while(1)
    {
/*
.
.
.
*/
    }
}
 
gboolean th_fonc(gpointer data)
{
    gdk_threads_enter();
    g_thread_create( alert,data,FALSE,NULL);
    gdk_threads_leave();
}

mais il me fais toujours ce warning :

Code :

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

1
2
3
 
main.c: In function `th_fonc':
main.c:45: warning: passing arg 1 of `g_thread_create_full' from incompatible pointer type

maintenant je doit utiliser un autre thread dans une fonction callback ,comment je doit procédé ? est ce de la meme facon ou bien il faut utiliser :
g_thread_create_full?

[gege2061]

Bonjour,

Code :

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

void *alert (gpointer *data)

Mauvaise signature :

Code :

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

gpointer (*GThreadFunc) (gpointer data);

[coax81]

et pour créer un autre thread faut il faire la meme chose ?

j'ai procédé de la facon suivante , mais il crée des bug !! mon prog plante :

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
 
 
 void *alert (gpointer data)
{
 
    int i;
    int val;
    while(1)
    {
 
    }
 
}
 
 void *alert2 (gpointer data)
{
 
    int i;
    int val;
    while(1)
    {
 
    }
 
}
 
gboolean th_fonc(gpointer data)
{
    gdk_threads_enter();
    g_thread_create(alert,data,FALSE,NULL);
    g_thread_create(alert2,data,FALSE,NULL);
    gdk_threads_leave();
}

dans le main :

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
 
int main(int argc, char **argv)
{
    g_thread_init (NULL);
    gdk_threads_init ();
    gdk_threads_enter ();
    gtk_init(&argc, &argv);
     /*
      .
      .
      .
     */
     g_idle_add(th_fonc,p_buff);//text_view2
 
    while (gtk_events_pending ()) {  gtk_main_iteration (); }
    gtk_main();
    gdk_threads_leave ();
    return EXIT_SUCCESS;
}

dans une callback:

Code :

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

1
2
3
4
5
 
 text_v  =gtk_text_view_new();
    gtk_widget_set_size_request(text_v, 100, 200);
    gtk_text_view_set_editable(GTK_TEXT_VIEW(text_v), FALSE);
    pb = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_v));

pb est declarée dans un .h :

Code :

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

1
2
 
GtkTextBuffer *pb;

[teuf13]

T'es certain d'avoir besoin d'un thread ? Une lecture périodique de ta donnée avec un g_idle_add serait peut être suffisante ?

[coax81]

ah oui ?
et est ce que je peu faire plusieurs iddle_add meme dans des callback ?

[teuf13]

Oui, tu peux faire autant de g_idle_add que tu veux. Ensuite ça dépend de ce que tu as en tête exactement

[coax81]

j'ai enlevé le thread , et j'ai copié la meme boucle while(1){} dans la fonction appelé par le thread et ca bloque l'interface !

[gege2061]

j'ai enlevé le thread , et j'ai copié la meme boucle while(1){} dans la fonction appelé par le thread et ca bloque l'interface !

L'appel à la fonction gtk_main_iteration n'est pas au bon endroit, tu doit le faire une fois que gtk_main est lancée.

Si je ne raconte pas d'âneries, gtk pioche dans le file de fonctions idle (dans ton cas, tu as la boucle principale de gtk et ta fonction alert), mais pour passé à une autre fonction, il faut que la première soit terminée. Or comme tu as une boucle sans fin, tu reste dans ta fonction et gtk_main ne reprend jamais la main (donc pas de rafraichissement de l'affichage).

Pour contourner le problème, soit tu appelles toi même gtk_main (avec gtk_main_iteration) soit tu utilise un timer.

Faudrais que je retrouve le message de la mailing list de gtk qui parle des threads parce que je ne vois pas comment exécuter deux fonctions en parallèles

[coax81]

je vois plus comment je doit faire ,
je peu pas créer un thread en parallèle avec ma boucle main , c'est la facon de faire qui m'echappe .. je sais pas si j'ai bien crée mon thread avec g_idle_add() , ou bien faut il pas créer de thread ?

il me faut une boucle infini qui modifie les valeur ecrites dans le gtktexview tout le temps , et j'ai un autre textview dans une autre fenetre ou je doit faire la meme chose quand j'appel cette fenetre , c'est pour cela je veu créer deux threads ... mais je sais pas si c'est une bonne idée

[teuf13]

On s'est mal compris en fait, le g_idle_add c'est pas un moyen simple de remplacer ton thread C'est une approche alternative au thread. Ca te permet d'avoir une fonction qui est appelée le plus souvent possible, mais si la fonction bloque, ça bloquera la mainloop gtk+ (à la différence d'un thread).

Ma suggestion initiale était sous forme de question parce que l'utilisation de g_idle_add nécessite de pouvoir "fragmenter" ce que fait la boucle while (1), ie est-ce que c'est suffisant de lire les données "suffisamment souvent" au lieu de "en permanence". Si la réponse est oui, tu peux avoir un g_idle_add où dans le callback tu fais "lire qques données; traiter ces données; return;"