Discussion :

[-N4w4k-]

Bonjour,

J'aurais besoin pour mon application d'un timer plus performant (interval ~1ms) que celui proposé par le framework (System.Windows.Form.Timer, ~18ms je crois).

J'ai commencé à écrire une classe mais mon problème c'est que quand je le lance, il monopolise les ressources, aucun traitement ne ce fait en parallèle.. J'ai testé avec un Application.DoEvents mais ça ne marche pas non plus..

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
Imports System.Threading
 
Public Class CycleTimer
    Private Declare Function timeGetTime Lib "winmm.dll" () As Integer
    Private Declare Function timeBeginPeriod Lib "winmm.dll" (ByVal uPeriod As Integer) As Integer
    Private Declare Function timeEndPeriod Lib "winmm.dll" (ByVal uPeriod As Integer) As Integer
    Private state As TimerState = TimerState.Stop
    Private threadStart As ParameterizedThreadStart
    Private timeStart As Long = 0
 
 
    Sub New(start As ParameterizedThreadStart)
        Me.threadStart = start
    End Sub
 
    Sub [Start](Optional period As Integer = 1)
        state = TimerState.Start
        timeBeginPeriod(period)
        timeStart = timeGetTime
        While state = TimerState.Start
 
            threadStart.Invoke(New Object() {})
 
            Threading.Thread.Sleep(period)
        End While
        timeStart = -1
        timeEndPeriod(period)
    End Sub
 
    Sub [Stop]()
        state = TimerState.Stop
    End Sub
 
    Function GetTime() As Long
        If timeStart <> -1 Then
            Return timeGetTime - timeStart
        Else
            Return -1
        End If
    End Function
 
    Private Enum TimerState
        [Start]
        [Stop]
    End Enum
 
End Class

Merci de votre aide.

[tomlev]

Qu'entends tu par "performant" ? Je suppose que tu parles plutôt de sa précision...

J'aurais besoin pour mon application d'un timer plus performant (interval ~1ms) que celui proposé par le framework (System.Windows.Form.Timer, ~18ms je crois).

System.Windows.Form.Timer n'est que l'un des timers proposés par le Framework... et il est imprécis pour une raison très simple : l'évènement Tick se déclenche toujours sur le thread UI, donc si le thread UI est occupé à autre chose à ce moment là, ça retarde le déclenchement du timer.

Pas la peine d'implémenter un nouveau timer, il y a déjà 2 classes qui devraient répondre à ton besoin :
System.Timers.Timer
System.Threading.Timer

Il y a un article ici avec une comparaison détaillée :
http://msdn.microsoft.com/en-us/magazine/cc164015.aspx

[-N4w4k-]

Salut tomlev,

en fait je suis en train de faire un logiciel de supervision qui a besoin de lire/écrire des entrées/sorties avec une grande précision.
Après quelques essais, le System.Windows.Form.Timer me semblait pas assez précis (je comprend maintenant pourquoi grâce à ton explication).

Je vais lire le comparatif que tu as mis en lien, mais à tout hasard, est ce qu'une solution est plus utilisée que d'autres pour ce genre de besoin?

EDIT: Le System.Threading.Timer à l'air de correspondre à mes besoins d'après msdn:

Le délégué de la minuterie est spécifié lors de la construction de cette dernière et ne peut pas être modifié. La méthode ne s'exécute pas dans le thread qui a créé la minuterie, mais dans un ThreadPool thread du pool fourni par le système.

[tomlev]

Perso j'ai une préférence pour System.Timers.Timer, qui a un modèle objet plus intuitif. La principale raison de préférer System.Threading.Timer, c'est si tu as besoin de contrôler à quel moment le timer se déclenche pour la première fois (paramètre dueTime)

[-N4w4k-]

J'étais parti sur l'autre ^^

En fait, je ne pense pas que mon problème vienne du timer.. Après le changement du System.Windows.Form.Timer en System.Threading.Timer, j'ai toujours le même problème. Les entrées ne sont apparemment pas lues assez souvent et tout les changements d'état de celles-ci ne sont pas pris en compte..

Je vais essayer dans une application console qui demandera peut être moins de ressources que mon application winforms.. J'espère qu'il y aura une différence car pour l'instant je ne sais pas du tout où se trouve mon erreur..

Dans le cas où je ne trouverais pas, je vous en dirais un peu plus sur ma démarche.

Merci pour ces réponses.

[-N4w4k-]

Bon bah je n'ai aucun changement.. J'ai ce problème depuis hier matin

Je ne sais plus où chercher.. Je vous post mon programme (appli console), peut être que vous pourrez me dire ce qui fait que tout les changements d'état des entrées ne sont pas pris en compte..

Main module:

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
Imports System.Timers
Imports ABW_IO_Manager
 
Module Module1
 
    'Cycle
    Private CurrentCycle As BaseCycle = New CurrentCycle
    Private ExecutionTimer As Timer
 
    'InputReader / OutputWriter
    Dim IOManager As IOManager = IOManager.GetInstance()
 
    Sub Main()
        Try
            'Init IO
            IOManager.InitInputs(CurrentCycle.FirstInput, CurrentCycle.LastInput)
            IOManager.InitOutputs(CurrentCycle.FirstOutput, CurrentCycle.LastOutput)
            'Init Cycle
            CurrentCycle.Inputs = IOManager.Inputs
            CurrentCycle.Outputs = IOManager.Outputs
            CurrentCycle.Init()
            'Init timer
            ExecutionTimer = New Timer(1)
            AddHandler ExecutionTimer.Elapsed, AddressOf Execute
 
            'Start timer
            ExecutionTimer.Enabled = True
 
            'Stop
            Console.WriteLine("Please Press any key to continue!")
            Console.ReadKey()
 
            'Deinit cycle
            CurrentCycle.Deinit()
            Threading.Thread.Sleep(100)
 
            'Stop timer
            ExecutionTimer.Enabled = False
 
        Catch ex As Exception
            Console.WriteLine(ex.Message)
            Console.WriteLine("Please Press any key to continue!")
            Console.ReadKey()
        End Try
    End Sub
 
    Sub Execute()
        Try
            IOManager.ReadInputs()
            CurrentCycle.Execute()
            IOManager.WriteOutputs()
 
        Catch ex As Exception
            Console.WriteLine(ex.Message)
        End Try
    End Sub
 
End Module

J'ai fais ça tout seul, et c'est là première fois que je le fais donc si vous avez une quelconque remarque, je suis preneur..

[tomlev]

Peut-être que la méthode Execute prend trop longtemps à s'exécuter (plus que l'intervalle entre 2 déclenchements du timer)

[-N4w4k-]

Ah.. Dis moi si je me trompe:

J'ai un seul Dictionary(of String, Boolean) qui stocke l'état de mes entrées quand j'éxécute l'instruction IOManager.ReadInputs(). Si mon appli met 5 millisecondes (chiffre au hasard) à analyser les entrées, et que le timer met à jour toutes les millesecondes le dico, je manquerais forcement des états.

Si c'est ça, comment puis je l'améliorer?? Est ce que cela veut dire que 1 ms est trop court?

PS: Voici ma méthode Execute()

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
    Public Overrides Sub Execute()
        'Detection d'un front montant de l'entrée E6
        If Inputs("E6") AndAlso Not LastE6Value Then AddPiece()
        LastE6Value = Inputs("E6")
 
 
        'Pour chaque piece en cours
        For Each Piece As Piece In New List(Of Piece)(PiecesCourantes)
            'lancement de l'analyse de chaque pièce dans un nouveau thread afin
            'de ne pas perturber l'analyse des autres pièces
            Dim t As New Threading.Thread(AddressOf AnalysePieceCourante)
            t.IsBackground = True
            t.Start(Piece)
        Next
    End Sub

[tomlev]

Tu démarres des nouveaux threads toutes les millisecondes ?
Je sais pas si tu réalises, mais créer un thread ça coute cher... Il y a sûrement une meilleure solution pour faire ce que tu veux.

Sinon, c'est quoi Inputs ? Un tableau ou une méthode ? Si c'est un tableau, il est modifié comment ?

Si c'est un tableau modifié par un autre thread, tu risques d'avoir des problèmes en lisant la valeur 2 fois, car elle pourrait avoir changé entre les 2. Il vaudrait mieux la lire une seule fois :

Code :

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

1
2
3
        Dim E6Value = Inputs("E6")
        If E6Value AndAlso Not LastE6Value Then AddPiece()
        LastE6Value = E6Value

D'autre part, ça ne sert à rien de créer une nouvelle liste pour faire ton ForEach, à part à perdre du temps :

Code :

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

        For Each Piece As Piece In PiecesCourantes

[-N4w4k-]

c'est quoi Inputs ?

C'est le Dictionary(Of String, Boolean) dont je parlais tout à l'heure, mis à jour quand IOManager.ReadInputs() est appelée (juste avant Execute())

ça ne sert à rien de créer une nouvelle liste pour faire ton ForEach, à part à perdre du temps

Pour la liste, je suis obliger d'en créer une autre car je modifie la liste originale entre temps (pièce éjectée -> suppression de la liste).

Tu démarres des nouveaux threads toutes les millisecondes ?

Euh bah oui Jusque là je n'ai pas trop remarqué de ralentissement car les threads lancés pour chaque pièce sont vite terminés (pour l'instant).
Je ne sais pas trop comment faire car pour être certain de détecter un front montant, il faut bien analyser le plus souvent possible non?

Si c'est un tableau modifié par un autre thread, tu risques d'avoir des problèmes en lisant la valeur 2 fois

Bonne remarque je n'y avait pas pensé. Je le change.

[tomlev]

Je ne sais pas trop comment faire car pour être certain de détecter un front montant, il faut bien analyser le plus souvent possible non?

Bah ça dépend du signal d'entrée...
Ils viennent d'où ces fronts montants ? Tu les lis à partir d'un périphérique externe ? Dans ce cas il y a peut-être une meilleure façon de les détecter

[Pol63]

il faudrait déjà nous dire ce que tu lis (port série ? réseau ? fichier ? ...)

en général ce qui se fait c'est un thread qui lit les données, qui les stocke seulement (comme ca c'est rapide et ca ne bloque pas la lecture)
et un autre thread qui traite les données, celui ci vérifiant une collection remplie par l'autre thread
éventuellement un autre thread qui prépare les données à écrire, après selon la ressource ce thread doit être le même que celui qui lit pour éviter les collisions
mais ceci demande du codage moins light, car il faut gérer les deadlocks et autre problème inhérents au multithreading (ajout un élément dans une collection pendant qu'un autre thread fait un for each et ca plante par exemple)

ceci est bien sur à pondérer par ton traitement, si les outputs doivent etre synchrones avec les inputs de l'instant T il faut alors améliorer les performances de traitement pour que sur chaque "tick" tu ne perdes pas de temps

[-N4w4k-]

Ils viennent d'où ces fronts montants ?

Alors en fait j'ai un capteur ("fourche" d'après les électriciens de ma boite, j'en sais pas plus..) que je "lis" par le biais d'une carte IO.

Le cycle: Il y a un plateau tournant (cylindrique..) sur lequel arrive des pièces (rectangulaire..), se font détecter par la fourche puis subissent toutes une série de test pour déterminer leur conformité. Au bout d'un certain temps, les pièces se font éjecter à l'aide d'une soufflette.

J'ai un peu cogité et en fait il faut que je détermine la durée minimum durant laquelle la pièce passe devant le capteur + la durée minimum durant laquelle il peut ne pas y avoir de pièce. La plus petite des deux valeurs me donnera la période maximum de mon timer. J'ai quelques données comme la vitesse de rotation du plateau, et je peux mesurer les pièces..

Je pense être sur la bonne voie maintenant et après plusieurs test, j'arrive à détecter pratiquement toutes les pièces (timer.interval = 30).

Je vous tiendrais au courant dès que les calculs/tests seront fait.

Merci encore pour ton aide.

[-N4w4k-]

@Pol63: Je pense que ce que j'ai fait est conforme à la description du processus que tu m'as donnée. En simplifiant et en regroupant les instructions, on obtiens ça:

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
    Sub Main() Handles Timer.Tick
 
        'Lecture des entrées / mise à jour de "Inputs" Dictionary(Of String, Boolean)
        IOManager.ReadInputs()
 
        'Analyse de l'entrée E6 -> Ajout piece si front montant detecté
        Dim E6value As Boolean = Inputs("E6")
        If E6value AndAlso Not LastE6Value Then AddPiece()
        LastE6Value = E6value
 
 
        'Pour chaque piece en cours
        For Each Piece As Piece In New List(Of Piece)(PiecesCourantes)
            'lancement de l'analyse de chaque pièce dans un nouveau thread
            Dim t As New Threading.Thread(AddressOf AnalysePieceCourante)
            t.IsBackground = True
            t.Start(Piece)
        Next
 
        'Ecriture des données d'après "Outputs", Dictionary(Of String, Boolean) mis à jour pendant l'exécution de la méthode AnalysePieceCourante
        IOManager.WriteOutputs()
    End Sub

- Lecture des entrées, stockage des états dans Dictionary "Inputs"
- Analyse du Dictionary "Inputs" (actuellement seulement E6 pour la détection d'une nouvelle pièce -> Ajout)
- Lancement d'un thread d’analyse par pièce actuellement sur le plateau (chargé de la mise à jour du Dictionary "Outputs" selon l'analyse)
- Ecriture des sorties selon le Dictionary "Outputs"

Cela me paraît cohérent.. Maintenant, je pense qu'il faut que je trouve le bon interval de temps entre chaque exécution de la méthode Execute en fonction de la vitesse de rotation du plateau, ses dimensions, les dimensions des pièces et l'écart minimum possible entre chacune d'elle.

J'espère pouvoir donner un résultat concluant demain dans la matinée..

[-N4w4k-]

Bon alors je me suis totalement embrouillé entre les threads, timers, tempos, etc. Plus j'avance et plus je recule
J'efface tout et je recommence.

Merci pour les précisions apportées qui m'ont données quelques clés avec lesquelles je peux desormais reprendre sur de bonnes bases.. meilleures en tout cas