Lebensbit überwachen

  • VB.NET

Es gibt 15 Antworten in diesem Thema. Der letzte Beitrag () ist von shad.

    Lebensbit überwachen

    Hallo,

    ich stehe gerade auf dem Schlauch...
    In meinem Programm habe ich ein Signal vom Typ Bool, das ständig zwischen 0/1 wechselt. Es ist eine Art Überlebensbit.
    Wie kann ich diese Bit überwachen, so dass es mir nach ich sage mal 10 Sekunden einen Fehler ausgibt, sobald kein Signalwechsel mehr stattfindet?

    Ich habe ein paar Timer-Varianten probiert, jedoch ohne Erfolg.

    VB.NET-Quellcode

    1. Dim IsAlive As Boolean = True

    Im Timer:

    VB.NET-Quellcode

    1. If Not IsAlive Then MessageBox.Show("Is Not Alive")
    2. IsAlive=False

    Da wo das Signal gesetzt wird:

    VB.NET-Quellcode

    1. Property Signal As Boolean
    2. Get
    3. Return Signal_
    4. End Get
    5. Set (value As Boolean)
    6. If Value <> Signal_ Then IsAlive = True
    7. Signal_ = value
    8. End Set
    9. End Property
    --
    If Not Program.isWorking Then Code.Debug Else Code.DoNotTouch
    --

    @petaod Nicht ganz.
    @Murdersquad In der Bit-Change-Property startest Du den 10-Sekunden-Timer neu, wenn das Signal geändert wird.
    Im Timer-Tick-Event meldest Du das Ausbleiben des Signals:

    VB.NET-Quellcode

    1. Property Signal As Boolean
    2. Get
    3. Return Signal_
    4. End Get
    5. Set (value As Boolean)
    6. If Value <> Signal_ Then Timer1.Start()
    7. Signal_ = value
    8. End Set
    9. End Property
    10. Sub Timer1_Tick()
    11. MessageBox.Show("Is Not Alive")
    12. End Sub
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    Extra Event klingt gut. Ggf. noch mit einem Async/Await+Task.Delay+CancellationTokenSource kombinieren, dann spart man sich die Timer-Komponente und man kann alles sauber innerhalb einer Klasse kapseln.
    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „VaporiZed“, mal wieder aus Grammatikgründen.

    Aufgrund spontaner Selbsteintrübung sind all meine Glaskugeln beim Hersteller. Lasst mich daher bitte nicht den Spekulatiusbackmodus wechseln.

    petaod schrieb:

    um die Überwachung zu aktivieren
    Das muss natürlich mit dem Start der Kommunikation überhaupt beginnen.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    Ich hatte mich in der Vergangenheit ja schon mal mit diesen einfachen Properties beschäftigt, aber verstehen tue ich sie noch immer nicht vollumfänglich. Wahrscheinlich muss ich es an einem funktionierenden Beispiel testen.

    Wieso gibt es einmal das Bit "Signal" und dann "Signal_"? Muss ich "Signal_ " noch irgendwo deklarieren?
    Wenn man Set (value as Boolean) schreibt, ist "value" dann automatisch schon auf True?

    VB.NET-Quellcode

    1. Property Signal As Boolean
    2. Get
    3. Return Signal_
    4. End Get
    5. Set (value As Boolean)
    6. If Value <> Signal_ Then Timer1.Start()
    7. Signal_ = value
    8. End Set
    9. End Property
    10. Sub Timer1_Tick()
    11. MessageBox.Show("Is Not Alive")
    12. End Sub



    Tut mir leid für die blöden Fragen :/

    @Murdersquad Das ist eine Property, die im Setter separaten Code ausführt.
    Wäre dies nicht der Fall, würde die Zeile

    VB.NET-Quellcode

    1. Property Signal As Boolean
    genügen.
    Ja, Signal_ muss separat deklariert werden:

    VB.NET-Quellcode

    1. Private Signal_ As Boolean

    Signal eine Property mit der beigeordneten Variable Signal_,
    Nicht initialisierte VAriablen stehen in .NET immer auf einem Null-Wert, bei einem Boolean wäre das False.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    Murdersquad schrieb:

    Wenn man Set (value as Boolean) schreibt, ist "value" dann automatisch schon auf True?
    Nein, der Wert von Value wird durch die Verwendung in Deinem Programm festgelegt.

    VB.NET-Quellcode

    1. Dim Testinstanz As New DeinObjekt
    2. Testinstanz.Signal = True

    Signal ist Deine Property. Sobald Du der einen Wert zuweist (Testinstanz.Signal = NeuerWert), wird der Property-Setter (also Set(value As Boolean)) aufgerufen, wobei value den Wert von NeuerWert, also in dem o.g. Codeblock True hat. Sobald Du den Wert von Signal abfragst, wird der Property-Getter, also die Get-Prozedur aufgerufen und der Wert von Signal_ zurückgegeben:

    VB.NET-Quellcode

    1. Dim x = Testinstanz.Signal

    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „VaporiZed“, mal wieder aus Grammatikgründen.

    Aufgrund spontaner Selbsteintrübung sind all meine Glaskugeln beim Hersteller. Lasst mich daher bitte nicht den Spekulatiusbackmodus wechseln.

    Ein Timer ist gar nicht nötig.

    Hier eine kleine Simulation. Es ist zwar ein Timer dabei, der ist jedoch nur für den Wechsel von LiveBit zuständig.

    EDIT: Ja das stimmt. Ist aber mit einer einfachen Sleep-Statement schon gelöst.
    Aus der Schleife muss er sowieso, da er an die Zeit gebunden ist.

    Freundliche Grüsse

    exc-jdbi

    Einfach nur Enter drücken und warten
    Spoiler anzeigen

    VB.NET-Quellcode

    1. Option Strict On
    2. Option Explicit On
    3. Imports System.Timers
    4. Public Module TestLiveBit
    5. Private MLiveBit As Int32
    6. Private Start As DateTime
    7. Private StopAfter As Int32
    8. Private Rand As New Random
    9. Private WithEvents Timer1 As New Timer
    10. Private Property LiveBit As Int32
    11. Get
    12. Return MLiveBit
    13. End Get
    14. Set(value As Int32)
    15. If DateTime.Now.Subtract(Start).Seconds <= StopAfter Then
    16. Start = DateTime.Now
    17. MLiveBit = value
    18. End If
    19. End Set
    20. End Property
    21. Public Sub Main()
    22. StopAfter = 5
    23. 'Startet den Timer der das LiveBit-Signal simuliert
    24. Dim s = "Press 'Enter' for stop LiveBit. Stop after {0}s."
    25. Console.WriteLine(s, StopAfter) : Console.WriteLine()
    26. TimerStart(True)
    27. Start = DateTime.Now
    28. Console.ReadLine()
    29. Console.WriteLine()
    30. Console.WriteLine("Wait .... {0}s", StopAfter)
    31. TimerStart(False)
    32. While True
    33. Threading.Thread.Sleep(1)
    34. If DateTime.Now.Subtract(Start).Seconds > StopAfter Then
    35. Exit Sub
    36. End If
    37. End While
    38. End Sub
    39. Private Sub TimerStart(_start As Boolean)
    40. If _start Then
    41. Timer1 = New Timer With {
    42. .Enabled = True,
    43. .Interval = 20
    44. }
    45. Timer1.Start()
    46. Return
    47. End If
    48. Timer1.Stop()
    49. Timer1.Enabled = False
    50. Timer1 = Nothing
    51. End Sub
    52. Private Sub Timer1_Tick(sender As Object, e As ElapsedEventArgs) Handles Timer1.Elapsed
    53. 'Der Timer wird nur gebrauch um das LiveBit-Signal zu simulieren
    54. LiveBit = Rand.Next(2)
    55. Console.Write(MLiveBit)
    56. End Sub
    57. End Module

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „exc-jdbi“ ()

    exc-jdbi schrieb:

    Es ist zwar ein Timer dabei, der ist jedoch nur für den Wechsel von LiveBit zuständig.
    Dafür läuft die Warte-Logik als CPU-fressende Endlosschleife im Haupt-Thread und blockiert alles restliche Tun.
    Das ist keine so gute Idee.
    --
    If Not Program.isWorking Then Code.Debug Else Code.DoNotTouch
    --

    exc-jdbi schrieb:

    VB.NET-Quellcode

    1. While True
    2. If DateTime.Now.Subtract(Start).Seconds > StopAfter Then
    3. Exit Sub
    4. End If
    5. End While
    Eine Endlosschleife in diesem Kontext ist ja wohl ein NoGo. :thumbdown:
    @petaod war schneller.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    Auch wenn Overkill, fasse ich mal Post#5 (von @FormFollowsFunction) und #6 zusammen:
    Spoiler anzeigen

    VB.NET-Quellcode

    1. Public Class FrmMain
    3. Private WithEvents TestInstance As New TestClass
    4. Private Sub FrmMain_Load(sender As Object, e As EventArgs) Handles MyBase.Load
    6. End Sub
    8. Private Sub BtnToggleAliveStatus_Click(sender As Object, e As EventArgs) Handles BtnToggleAliveStatus.Click
    9. TestInstance.Signal = Not TestInstance.Signal
    10. LblAliveStatus.Text = TestInstance.Signal.ToString
    11. End Sub
    13. Private Sub TestInstance_IsDead(sender As Object, e As EventArgs) Handles TestInstance.IsDead
    14. MessageBox.Show("It's dead!")
    15. Me.Close()
    16. End Sub
    17. End Class
    19. Public Class TestClass
    20. Private _Signal As Boolean = False
    21. Private CancelSignContainer As Threading.CancellationTokenSource = Nothing
    22. Public Event IsDead As EventHandler
    24. Public Property Signal As Boolean
    25. Get
    26. Return _Signal
    27. End Get
    28. Set(value As Boolean)
    29. _Signal = value
    30. PossiblyStartTimer()
    31. End Set
    32. End Property
    34. Private Async Sub PossiblyStartTimer()
    35. If _Signal Then
    36. CancelSignContainer?.Cancel()
    37. CancelSignContainer?.Dispose()
    38. CancelSignContainer = Nothing
    39. Return
    40. End If
    42. CancelSignContainer = New Threading.CancellationTokenSource
    43. Dim CancelSign = CancelSignContainer.Token
    44. Dim WaitingTask = Threading.Tasks.Task.Delay(10000, CancelSign)
    45. Try
    46. Await WaitingTask
    47. RaiseEvent IsDead(Me, Nothing)
    48. Catch TCEx As Threading.Tasks.TaskCanceledException
    49. If WaitingTask.IsCanceled Then
    50. 'it's still alive!
    51. End If
    52. Finally
    53. CancelSignContainer.Dispose()
    54. CancelSignContainer = Nothing
    55. End Try
    56. End Sub
    57. End Class

    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „VaporiZed“, mal wieder aus Grammatikgründen.

    Aufgrund spontaner Selbsteintrübung sind all meine Glaskugeln beim Hersteller. Lasst mich daher bitte nicht den Spekulatiusbackmodus wechseln.

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „VaporiZed“ ()

    Das Problem hier fand ich interessant, deswegen wollte ich mal schnell schauen, wie ich es angegangen wäre. Das ganze schrie für mich nach INotifyPropertyChanged, um die eigentliche Änderung des Bits schön vom Überwachen trennen. Das hier ist dabei rausgekommen - vielleicht interessiert es ja jemanden.

    C#

    C#-Quellcode

    1. using System;
    2. using System.ComponentModel;
    3. using System.Threading.Tasks;
    5. public class SignalEmitter : INotifyPropertyChanged {
    6. public event PropertyChangedEventHandler PropertyChanged;
    8. private bool _signal;
    9. public bool Signal {
    10. get { return _signal; }
    11. set {
    12. if (_signal != value) {
    13. _signal = value;
    14. PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Signal)));
    15. }
    16. }
    17. }
    18. }
    20. public sealed class TimedPropertyChangedObserver : IDisposable {
    21. private INotifyPropertyChanged _subject;
    22. private readonly string _propertyToObserve;
    23. private readonly TimeSpan _delay;
    24. private int _lastChangeId;
    26. public event EventHandler TimeExceeded;
    28. public TimedPropertyChangedObserver(INotifyPropertyChanged subject, string propertyToObserve, TimeSpan delay) {
    29. _subject = subject;
    30. _propertyToObserve = propertyToObserve;
    31. _delay = delay;
    32. _subject.PropertyChanged += Subject_PropertyChanged;
    33. }
    35. private async void Subject_PropertyChanged(object sender, PropertyChangedEventArgs e) {
    36. if (e.PropertyName == _propertyToObserve) {
    37. _lastChangeId++;
    38. var thisChangeId = _lastChangeId;
    40. await Task.Delay(_delay);
    42. if (_lastChangeId == thisChangeId) {
    43. TimeExceeded?.Invoke(this, EventArgs.Empty);
    44. }
    45. }
    46. }
    48. public void Dispose() {
    49. _subject.PropertyChanged -= Subject_PropertyChanged;
    50. _subject = null;
    51. }
    52. }
    54. public class Program {
    55. static void Main(string[] args) {
    56. var subject = new SignalEmitter();
    57. using var observer = new TimedPropertyChangedObserver(subject, nameof(SignalEmitter.Signal), TimeSpan.FromSeconds(5));
    58. observer.TimeExceeded += (s, e) => Console.WriteLine("The object died.");
    60. Console.WriteLine("Press ENTER to change the property.");
    61. while (true) {
    62. Console.ReadLine();
    63. subject.Signal = !subject.Signal;
    64. Console.WriteLine($"Signal is now {subject.Signal}.");
    65. }
    66. }
    67. }


    (Mit Code Converter, evtl. nicht perfektes VB):
    VB

    VB.NET-Quellcode

    1. Imports System
    2. Imports System.ComponentModel
    3. Imports System.Threading.Tasks
    5. Public Class SignalEmitter
    6. Implements INotifyPropertyChanged
    8. Public Event PropertyChanged As PropertyChangedEventHandler
    9. Private _signal As Boolean
    11. Public Property Signal As Boolean
    12. Get
    13. Return _signal
    14. End Get
    15. Set(ByVal value As Boolean)
    17. If _signal <> value Then
    18. _signal = value
    19. PropertyChanged?.Invoke(Me, New PropertyChangedEventArgs(NameOf(Signal)))
    20. End If
    21. End Set
    22. End Property
    23. End Class
    25. Public NotInheritable Class TimedPropertyChangedObserver
    26. Implements IDisposable
    28. Private _subject As INotifyPropertyChanged
    29. Private ReadOnly _propertyToObserve As String
    30. Private ReadOnly _delay As TimeSpan
    31. Private _lastChangeId As Integer
    32. Public Event TimeExceeded As EventHandler
    34. Public Sub New(ByVal subject As INotifyPropertyChanged, ByVal propertyToObserve As String, ByVal delay As TimeSpan)
    35. _subject = subject
    36. _propertyToObserve = propertyToObserve
    37. _delay = delay
    38. AddHandler _subject.PropertyChanged, AddressOf Subject_PropertyChanged
    39. End Sub
    41. Private Async Sub Subject_PropertyChanged(ByVal sender As Object, ByVal e As PropertyChangedEventArgs)
    42. If e.PropertyName = _propertyToObserve Then
    43. _lastChangeId += 1
    44. Dim thisChangeId = _lastChangeId
    45. Await Task.Delay(_delay)
    47. If _lastChangeId = thisChangeId Then
    48. TimeExceeded?.Invoke(Me, EventArgs.Empty)
    49. End If
    50. End If
    51. End Sub
    53. Public Sub Dispose()
    54. RemoveHandler _subject.PropertyChanged, AddressOf Subject_PropertyChanged
    55. _subject = Nothing
    56. End Sub
    57. End Class
    59. Public Class Program
    60. Private Shared Sub Main(ByVal args As String())
    61. Dim subject = New SignalEmitter()
    63. Using observer = New TimedPropertyChangedObserver(subject, NameOf(SignalEmitter.Signal), TimeSpan.FromSeconds(5))
    65. observer.TimeExceeded += Function(s, e) Console.WriteLine("The object died.")
    66. Console.WriteLine("Press ENTER to change the property.")
    68. While True
    69. Console.ReadLine()
    70. subject.Signal = Not subject.Signal
    71. Console.WriteLine($"Signal is now {subject.Signal}.")
    72. End While
    73. End Sub
    74. End Class

Facebook
Telefonspende