Problème thread programme

Version imprimable

bonjour à tous, je rencontre des difficultés pour mettre en place des thread pour ma méthode codeurvaleur de la classe Codeur afin que celui-ci tourne quand il est appelé.
Plus tard, la valeur fournit par codeurvaleur sera afficher par un afficheur lui aussi tournant en boucle avec un thread tout les 0.5 seconde voir 1 seconde. Les méthode doivent pouvoir tourner tous les 0.5 secondes en fond sans gêner d'autre tâche et lancer d'autre méthode ...
J'ai déjà suivie plusieurs tuto et astuce, mais impossible de faire fonctionner.

-----------------------------------------------------------------------------------------
Classe Capteur.cs

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
namespace Capteur
{
    class Capteur : noeud_can
    {
        private int ValeurCapteurFinal;
 
        public int ValeurcapteurFinal
        { get { return ValeurCapteurFinal; } }
 
        //constructeur par defaut 
        public Capteur(string nom_peripherique, UInt16 numero_noeud)
              : base(nom_peripherique, numero_noeud)
          {
          }
 
        public void capteurvaleur()
        {
            //COB ID
            uint COB_ID_emission_sdo = (uint)0x600 + numero_noeud;
            uint COB_ID_reception_sdo = (uint)0x580 + numero_noeud;
 
            Console.WriteLine("debut de la capture");
            // Envoie de la trame pour lire l'entrée analogique numéro 2 du variateur
            // 0x40  -  Read Request = requête de lecture d'un paramètre du variateur  
            // 5fe3 - affichage de la tension d'entrée aux entrées analogiques
            // plage d'affichage du capteur : -10.00 a +10.00 
            // 0x02  -  tension d'entrée AIN2
            envoyer_trame(COB_ID_emission_sdo, 8, 0x40, 0xe3, 0x5f, 0x02, 0x0, 0x0, 0x0, 0x0);
            Console.WriteLine("\nenvoi de la trame de lecture de la valeur d'entrée");
            Thread.Sleep(100);
 
            //Trame réponse du variateur
            //recevoir_trame(COB_ID_reception_sdo, 8);
            TPCANMsg message_reponse;
            message_reponse = recevoir_trame(COB_ID_reception_sdo, 8);
            Thread.Sleep(100);
 
            #region conversion
            string disthexa = message_reponse.DATA[5].ToString("X");  
            string disthexa2 = disthexa + message_reponse.DATA[4].ToString("X"); 
            int intAgain = int.Parse(disthexa2, System.Globalization.NumberStyles.HexNumber);
            Console.WriteLine(intAgain);
 
            int ValeurDivision = (intAgain * 2);
            this.ValeurCapteurFinal = (ValeurDivision / 10);
            Console.WriteLine("La distance est de {0} mm", this.ValeurCapteurFinal);
            /*int ValeurTraitement = (ValeurDivision / 10);
            Console.WriteLine("La distance est de {0} mm", ValeurTraitement);*/
 
            #endregion
        }
    }
}

---------------------------------------------------------------------------------------------
Classe Codeur.cs

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
namespace Codeur
{
    class Codeur : noeud_can
    {
        private int ValeurCodeurFinal;
 
        public int ValeurcodeurFinal
        { get { return ValeurCodeurFinal; } }
 
        //constructeur par defaut 
        public Codeur(string nom_peripherique, UInt16 numero_noeud)
              : base(nom_peripherique, numero_noeud)
          {
          }
 
        public void codeurvaleur(Capteur capteur)
        {
            //var grid = (Capteur)capteur;
            if ((capteur.ValeurcapteurFinal != 0))
            {
                //Console.WriteLine("ValeurCapteur{0}", capteur.ValeurcapteurFinal);
                //Console.ReadKey();
 
                //COB ID
                uint COB_ID_emission_sdo = (uint)0x600 + numero_noeud;
                uint COB_ID_reception_sdo = (uint)0x580 + numero_noeud; 
 
                Console.WriteLine("debut de la capture");
       //Envoie de la trame pour lire l'entrée analogique numéro 2 du variateur
       //0x40 - requête de lecture d'un paramètre du variateur     64 en décimal    4 octets
      //5cbd - affichage de valeurs d'entrée 32 bits de différents blocs en [incréments]
        // plage d'affichage du capteur : -2147483647 a +2147483647   
        // 0x5 - sous index 5  MCTRL: dn PosSetValue_p
           envoyer_trame(COB_ID_emission_sdo, 8, 0x40, 0xbd, 0x5c, 0x05, 0x0, 0x0, 0x0, 0x0);
                Console.WriteLine("\nenvoi de la trame de lecture de la valeur d'entrée");
                Thread.Sleep(100);
 
                //Trame réponse du variateur
                //recevoir_trame(COB_ID_reception_sdo, 8);
                TPCANMsg message_reponse;
                message_reponse = recevoir_trame(COB_ID_reception_sdo, 8);
                Thread.Sleep(100);
 
                #region Conversion valeur codeur
                string disthexa = message_reponse.DATA[7].ToString("X2");
                string disthexa2 = disthexa + message_reponse.DATA[6].ToString("X2");
 
         int intAgain = int.Parse(disthexa2, System.Globalization.NumberStyles.HexNumber);
 
                Console.WriteLine(intAgain);
                int tour = (intAgain);     // Mise a l'échelle : 65535 = 1 tour
                double tourcodeur = (tour * 0.2);
                Console.WriteLine("Nombres de tours : " + tour);
                Console.WriteLine("nombres de centimètre : {0}", tourcodeur);
                #endregion
 
                #region Valeur pour afficheur (calcule)
 
                double ResultatCapteurCodeur = (capteur.ValeurcapteurFinal - tourcodeur);
                this.ValeurCodeurFinal = Convert.ToInt32(ResultatCapteurCodeur);
                Console.WriteLine("La distance restant est de {0} mm", ValeurCodeurFinal);
 
                #endregion
            }
            else
            {
                Console.WriteLine("ValeurcapteurFinal n'a pas la bonne valeur !");
            }
        }
    }
}

---------------------------------------------------------------------------------------------
Programclasse.cs

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
namespace Programme
{
    class Programsansclasse
    {
        static void Main(string[] args)
        {
            #region Fonctionnement
 
            #region Capteur
            Capteur CAPTEUR = new Capteur("UPK 500 POR", 1);
            #endregion
 
            CAPTEUR.capteurvaleur();   //Fonctionnement du capteur
            Thread.Sleep(5000);
 
            #region Afficheur
            Afficheur AFFICHEUR = new Afficheur("CA340", 2);
            #endregion
 
            AFFICHEUR.CapteurValeurAfficheur(CAPTEUR);
 
            Thread.Sleep(5000);
 
            #region Codeur
            Codeur CODEUR = new Codeur("Codeur variateur", 1);
            #endregion
 
            Thread.Sleep(5000);
 
            // Create the thread object, passing in the CODEUR.codeurvaleur(CAPTEUR) method
            // via a ThreadStart delegate. This does not start the thread.
       var CapteurBoucle = new Thread(new ParameterizedThreadStart(CAPTEUR.capteurvaleur()));
            //Start the thread
            CapteurBoucle.Start();
 
            Thread.Sleep(50);
            #endregion
            Console.ReadKey();
        }
    }
}

----------------------------------------------------
L'erreur produit est celle-ci:
Erreur 1 Nom de méthode attendu ...\....\Programclasse.cs 84 73 Afficheur-capteur

ligne de l'erreur :
var CapteurBoucle = new Thread(new ParameterizedThreadStart(CAPTEUR.capteurvaleur()));

Faisons simple pour commencer.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
        private void button1_Click(object sender, EventArgs e)
        {
            Capteur CAPTEUR = new Capteur();
            Thread T = new Thread(CAPTEUR.capteurvaleur);
            T.Start();
        }
    }
 
    public class Capteur
    {
        public void capteurvaleur()
        {
            Thread.Sleep(500);
            Console.WriteLine("OK");
        }
    }

Salut, un petit exemple avec un Thread de capture et un Thread d'affichage.

Une petite remarque sur ton code, pour une classe qui fait l’acquisition de données en provenance d'un capteur je n'ai pas réussi à trouver de boucle ? Si bien que l'acquisiton se fait une fois et puis s'arrête... Est-ce normal ?

Je ne sais pas quelle techno tu utilises (WinForms ?) mais il faudra mettre ton Thread d'affichage dans la Form et utiliser des invoker pour manipuler les contrôles.
Inutile de créer une classe Afficheur si c'est le cas.

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
 
class Program
    {
        static void Main(string[] args)
        {
 
            Capteur capteur = new Capteur();
 
            Afficheur afficheur = new Afficheur(capteur);
 
 
            while(true)
            {
                Console.WriteLine();
                Console.WriteLine("Pressez A pour démarrer le capteur.");
                Console.WriteLine("Pressez B pour démarrer l'e afficheur.");
                Console.WriteLine("Pressez C pour arréter le capteur.");
                Console.WriteLine("Pressez D pour arréter l'afficheur.");
                Console.WriteLine("Pressez Q pour quitter.");
                var key = Console.ReadKey();
 
                if(key.Key == ConsoleKey.A)
                {
                    capteur.DepartCapture();
                }
                else if (key.Key == ConsoleKey.B)
                {
                    afficheur.DepartAffichage();
                }
                else if (key.Key == ConsoleKey.C)
                {
                    capteur.StopCapture();
                }
                else if (key.Key == ConsoleKey.D)
                {
                    afficheur.StopAffichage();
                }
                else if (key.Key == ConsoleKey.Q)
                {
                    break;
                }
            }
        }
    }
 
    class Capteur
    {
        public object m_LockValeur = new object();
        private long _Valeur;
        public long m_Valeur
        {
            get
            {
                lock(m_LockValeur)
                {
                    return _Valeur;
                }
            }
            private set
            {
                lock (m_LockValeur)
                {
                    _Valeur = value;
                }
            }
        }
        private bool m_Stop = false;
 
 
        public void DepartCapture()
        {
            Task.Factory.StartNew(Capture);
        }
 
        private void Capture()
        {
            Console.WriteLine("Début de la capture");
            this.m_Stop = false;
            while (!this.m_Stop)
            {
                this.m_Valeur = DateTime.Now.Ticks;
                Console.WriteLine("Capture valeur = {0}", this.m_Valeur);
                Thread.Sleep(1000);
            }
            Console.WriteLine("Fin de la capture");
        }
 
        public void StopCapture()
        {
            this.m_Stop = true;
        }
    }
 
    class Afficheur
    {
 
        private bool m_Stop = false;
        private readonly Capteur m_Capteur;
        public Afficheur(Capteur pCapteur)
        {
            this.m_Capteur = pCapteur;
        }
 
 
        public void DepartAffichage()
        {
            Task.Factory.StartNew(Affichage);
        }
 
        private void Affichage()
        {
            Console.WriteLine("Début de l'affichage");
            this.m_Stop = false;
            while (!this.m_Stop)
            {
                Console.WriteLine("Affichage valeur = {0}", this.m_Capteur.m_Valeur);
                Thread.Sleep(1000);
            }
            Console.WriteLine("Fin de l'affichage");
        }
 
        public void StopAffichage()
        {
            this.m_Stop = true;
        }
    }

Voilà tiens nous au courant.

Merci de vos réponse. J'ai réussie à résoudre mon problème de thread pour ma méthode et j'ai pu l'appliquer à ma classe afficheur.
J'utilise une application console, qui plus tard sera en WinForms.

----------------

ProgramClass:

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
 class Programsansclasse
    {
        static void Main(string[] args)
        {
 
         // Code ...
 
         Codeur CODEUR = new Codeur("Codeur variateur", 1);  // numero du noeud (1)
            bool retour4 = false;
 
            //initialiser la première interface usb/can avec un baurate de 250 kBit/sec
            retour4 = CODEUR.configurer((byte)PCANBasic.PCAN_USBBUS1, TPCANBaudrate.PCAN_BAUD_250K);   //  TPCANHandle 0x51 -> PCAN-USB interface, channel 1      PCAN_BAUD_250K -> 250 kBit/s
            if (retour4)
                Console.WriteLine("configuration réussie");
            else
                Console.WriteLine("echec de la configuration");
 
 
 
            Console.WriteLine("Lancement boucle");
 
            // Create the thread object, passing in the (CODEUR.codeurvaleur) method
            // via a ThreadStart delegate. This does not start the thread.
            var CodeurBoucle = new Thread(new ParameterizedThreadStart(CODEUR.codeurvaleur));
            //Start the thread
            CodeurBoucle.Start(CAPTEUR);
 
            // Suite code ...

---------------------------------
Classe Codeur.cs :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
        public void codeurvaleur(object capteur)
        {
            while (Thread.CurrentThread.IsAlive)
            {
                Capteur grid = (Capteur)capteur;
                if ((grid.ValeurcapteurFinal != 0))
                {
                   // Code méthode ...
                }
                else
                {
                    Console.WriteLine("ValeurcapteurFinal n'a pas la bonne valeur !");
                }
            }
        }
    }
}

---------------------------------------

Par rapport aux réponses que vous m'avez apportées, elle me seront très utile pour simplifier mon code et de le rendre plus visible.

12/05/2016, 18h52
ericlm128

Code:

while (Thread.CurrentThread.IsAlive)

Il sera toujours vrai donc pourquoi ne pas mettre

Code:

While (true)

Pense comme même à mettre tes propriété partagé en volatile ou utilise un lock ça t’évitera des problèmes aléatoires.
https://msdn.microsoft.com/fr-fr/library/x13ttww7.aspx
https://msdn.microsoft.com/fr-fr/library/c5kehkcz.aspx