Add timer overflow watchdog to listener class #14

New Issue

2023-03-03T12:30:44+01:00

winterhalderp commented

2023-03-03 12:30:44 +01:00

ROS2_pubsub/src/pubsub/pubsub/pubsub_library_v3.py Line 113 in c1d9c6e33c

in listener_callback zusätzliche variable self.last_msg_time = systime erstellen.

Watchdog-Methode implementieren:

def timer_overflow(self, time_limit=0):
    """
    true = timer_overflow >> error
    false = nmo timer_overflow >> no error
    """
    if time_limit > 0:
    	vergleich systemtime mit last_msg_time(systemtime)
        falls > overflow = true
        ansonsten overflow = false
    return overflow

https://egit.irs.uni-stuttgart.de/RoverLehre/ROS2_pubsub/src/commit/c1d9c6e33ce41323c06ccbfe695696d46f5bd77a/src/pubsub/pubsub/pubsub_library_v3.py#L113 in listener_callback zusätzliche variable `self.last_msg_time = systime` erstellen. Watchdog-Methode implementieren: ``` def timer_overflow(self, time_limit=0): """ true = timer_overflow >> error false = nmo timer_overflow >> no error """ if time_limit > 0: vergleich systemtime mit last_msg_time(systemtime) falls > overflow = true ansonsten overflow = false return overflow ```

cherr added reference library_v4

2023-03-25 16:23:34 +01:00

cherr commented

2023-03-25 16:24:10 +01:00

issue implemented into library v4, needs to be verified.

winterhalderp commented

2023-03-26 16:26:25 +02:00

Ggf auf diese Weise implementieren

Für timeout innerhalb Klasse abspeichern, zb. innerhalb `init` zwei Standard-Variablen anlegen:

def __init__(self, ...params...):
    code ...
    self.timelimit = None
    self.last_msg_received = None
    code ...

Dann zusätzliche Methoden innerhalb Klasse definieren, um das Verhalten weiter zu konfigurieren:

def timeout_limit(self, timelimit=None):
    if timelimit == Node:
        print("No timeout set within {Name des Subscribers, s. self-variablen}"%(...))
        return
    else:
        print("Timelimit for {Name Subscriber} set to %s"%(self.name, timelimit)) 
        self.timelimit = timelimit
        return

Auf diese Weise, wird vermieden, dass zu viele Parameter beim Erstellen einer Instanz als Parameter übergeben werden müssen, das macht das Ganze etwas übersichtlicher.

Dann Methode zum Prüfen des timeout hinzufügen:

def timeout(self):
    if self.time_limit == None: # Prüfen, ob interner timelimit definiert?
        return False # Falls nein, timeout = False
        
    else: # Prüfen ob timelimit
        current_time = systime...
        if (current_time - self.last_msg_received) > self.timelimit:
            return False
        else:
            return False

Diese Methode ruft man dann von außen auf (main) und fragt ab, ob timeout passiert ist.

Hier bitte alles noch besser benennen, zb anstelle timer_overflow eher timeout.

Eigentlich könnte man alle Minimal-Klassen auf diese Weise überarbeiten, und die Konfiguration in eigene Methoden verpacken. Dadurch kann man die Anzahl Parameter reduzieren, die beim Erstellen der Instanz benötigt werden.

Ggf auf diese Weise implementieren ### Für timeout innerhalb Klasse abspeichern, zb. innerhalb `__init__` zwei Standard-Variablen anlegen: ``` def __init__(self, ...params...): code ... self.timelimit = None self.last_msg_received = None code ... ``` ### Dann zusätzliche Methoden innerhalb Klasse definieren, um das Verhalten weiter zu konfigurieren: ``` def timeout_limit(self, timelimit=None): if timelimit == Node: print("No timeout set within {Name des Subscribers, s. self-variablen}"%(...)) return else: print("Timelimit for {Name Subscriber} set to %s"%(self.name, timelimit)) self.timelimit = timelimit return ``` Auf diese Weise, wird vermieden, dass zu viele Parameter beim Erstellen einer Instanz als Parameter übergeben werden müssen, das macht das Ganze etwas übersichtlicher. ### Dann Methode zum Prüfen des timeout hinzufügen: ``` def timeout(self): if self.time_limit == None: # Prüfen, ob interner timelimit definiert? return False # Falls nein, timeout = False else: # Prüfen ob timelimit current_time = systime... if (current_time - self.last_msg_received) > self.timelimit: return False else: return False ``` Diese Methode ruft man dann von außen auf (main) und fragt ab, ob timeout passiert ist. Hier bitte alles noch besser benennen, zb anstelle ```timer_overflow``` eher ```timeout```. Eigentlich könnte man alle Minimal-Klassen auf diese Weise überarbeiten, und die Konfiguration in eigene Methoden verpacken. Dadurch kann man die Anzahl Parameter reduzieren, die beim Erstellen der Instanz benötigt werden.

Sign in to join this conversation.

2 Participants

Notifications

Due Date

No due date set.

Dependencies

No dependencies set.

Reference: RoverLehre/ROS2_pubsub#14

Add timer overflow watchdog to listener class #14

Für timeout innerhalb Klasse abspeichern, zb. innerhalb __init__ zwei Standard-Variablen anlegen:

Dann zusätzliche Methoden innerhalb Klasse definieren, um das Verhalten weiter zu konfigurieren:

Dann Methode zum Prüfen des timeout hinzufügen:

Für timeout innerhalb Klasse abspeichern, zb. innerhalb `init` zwei Standard-Variablen anlegen: