refactored codebase

msg/State.msg

-string  component # Name of the component, whose
-                  # critical level is monitored.
-float32 critical  # Critical level of the family.
\ No newline at end of file

msg/States.msg

-State[] states # Array of states.

src/visualising/animation.py

@@ -2,29 +2,33 @@
 
 import re
 import importlib.resources
+
 from . import animations
-from visualising.exception import AnimationException
+from visualising.exception import VisualiseException
 
 
 class Animation:
+
+    source = "animation.py"  # Name of the file that contains the Animation class definition.
+
     def __init__(self, frames, frame_time, num_iter):
         # Set frames, number of frames and number of ensembles.
         try:
             animation_len = len(frames)
         except TypeError:
-            raise AnimationException("P: -- ERROR -- The animation is empty!")
+            raise VisualiseException(source, "The animation is empty!")
 
         if animation_len % 2 != 0:
-            raise AnimationException("P: -- ERROR -- Animation must contain an even number of frames!")
+            raise VisualiseException(source, "Animation must contain an even number of frames!")
         else:
             for frame in frames:
                 try:
                     frame_len = len(frame)
                 except TypeError:
-                    raise AnimationException("P: -- ERROR -- At least one frame is empty!")
+                    raise VisualiseException(source, "At least one frame is empty!")
 
                 if frame_len != 48:
-                    raise AnimationException("P: -- ERROR -- At least one frame doesn't have exactly 48 values!")
+                    raise VisualiseException(source, "At least one frame doesn't have exactly 48 values!")
                 else:
                     is_numeric = True
                     is_positive = True
@@ -36,11 +40,11 @@ class Animation:
                         is_small = is_small and value < 256
 
                     if not is_numeric:
-                        raise AnimationException("P: -- ERROR -- Not all values in the animation are integers!")
+                        raise VisualiseException(source, "Not all values in the animation are integers!")
                     elif not is_positive:
-                        raise AnimationException("P: -- ERROR -- Not all values in the animation are positive!")
+                        raise VisualiseException(source, "Not all values in the animation are positive!")
                     elif not is_small:
-                        raise AnimationException("P: -- ERROR -- One or more values in the animation are to large!")
+                        raise VisualiseException(source, "One or more values in the animation are to large!")
                     else:
                         self.frames = frames
                         self.num_frames = animation_len
@@ -48,21 +52,21 @@ class Animation:
 
         # Set frame time.
         if not isinstance(frame_time, int):
-            raise AnimationException("P: -- ERROR -- Frame time must be an integer!")
+            raise VisualiseException(source, "Frame time must be an integer!")
         elif frame_time < 0:
-            raise AnimationException("P: -- ERROR -- Frame time must be positive!")
+            raise VisualiseException(source, "Frame time must be positive!")
         elif frame_time > 4294967295:
-            raise AnimationException("P: -- ERROR -- Animation delay is to high!")
+            raise VisualiseException(source, "Animation delay is to high!")
         else:
             self.frame_time = frame_time
 
         # Set number of iterations.
         if not isinstance(num_iter, int):
-            raise AnimationException("P: -- ERROR -- Number of iterations must be an integer!")
+            raise VisualiseException(source, "Number of iterations must be an integer!")
         elif num_iter > 255:
-            raise AnimationException("P: -- ERROR -- Animation has to many iterations!")
+            raise VisualiseException(source, "Animation has to many iterations!")
         elif num_iter <= 0:
-            raise AnimationException("P: -- ERROR -- Animation must have at least one iteration!")
+            raise VisualiseException(source, "Animation must have at least one iteration!")
         else:
             self.num_iter = num_iter
 
@@ -71,11 +75,11 @@ class Animation:
         try:
             file = importlib.resources.open_text(animations, filename)
         except AttributeError:
-            raise AnimationException("P: -- ERROR -- The file is incorrectly formatted!")
+            raise VisualiseException(source, "The file is incorrectly formatted!")
         except FileNotFoundError:
-            raise AnimationException("P: -- ERROR -- The specified file does not exist!")
+            raise VisualiseException(source, "The specified file does not exist!")
         except TypeError:
-            raise AnimationException("P: -- ERROR -- No animation file was specified!")
+            raise VisualiseException(source, "No animation file was specified!")
 
         animation = []
         for line in file:
@@ -99,19 +103,19 @@ class Animation:
         try:
             ensemble_len = len(ensemble)
         except TypeError:
-            raise AnimationException("P: -- ERROR -- Ensemble is empty!")
+            raise VisualiseException(source, "Ensemble is empty!")
 
         if ensemble_len != 2:
-            raise AnimationException("P: -- ERROR -- Ensemble doesn't contain exactly two frames!")
+            raise VisualiseException(source, "Ensemble doesn't contain exactly two frames!")
         else:
             for frame in ensemble:
                 try:
                     frame_len = len(frame)
                 except TypeError:
-                    raise AnimationException("P: -- ERROR -- At least one frame is empty!")
+                    raise VisualiseException(source, "At least one frame is empty!")
 
                 if frame_len != 48:
-                    raise AnimationException("P: -- ERROR -- At least one frame doesn't have exactly 48 values!")
+                    raise VisualiseException(source, "At least one frame doesn't have exactly 48 values!")
                 else:
                     is_numeric = True
                     is_positive = True
@@ -123,22 +127,22 @@ class Animation:
                         is_small = is_small and value < 256
 
                     if not is_numeric:
-                        raise AnimationException("P: -- ERROR -- Not all values in the ensemble are integers!")
+                        raise VisualiseException(source, "Not all values in the ensemble are integers!")
                     elif not is_positive:
-                        raise AnimationException("P: -- ERROR -- Not all values in the ensemble are positive!")
+                        raise VisualiseException(source, "Not all values in the ensemble are positive!")
                     elif not is_small:
-                        raise AnimationException("P: -- ERROR -- One or more values in the ensemble are to large!")
+                        raise VisualiseException(source, "One or more values in the ensemble are to large!")
                     else:
                         if not (0 < pixel < 33):
-                            raise AnimationException("P: -- ERROR -- Pixel has to be in the range of 1 to 32!")
+                            raise VisualiseException(source, "Pixel has to be in the range of 1 to 32!")
                         elif not (0 < r < 256):
-                            raise AnimationException("P: -- ERROR -- Red channel value has to be in the range of 1 to "
-                                                     "255!")
+                            raise VisualiseException(source, "Red channel value has to be in the range of 1 "
+                                                     "to 255!")
                         elif not (0 < g < 256):
-                            raise AnimationException("P: -- ERROR -- Green channel value has to be in the range of 1 "
+                            raise VisualiseException(source, "Green channel value has to be in the range of 1 "
                                                      "to 255!")
                         elif not (0 < b < 256):
-                            raise AnimationException("P: -- ERROR -- Blue channel value has to be in the range of 1 "
+                            raise VisualiseException(source, "Blue channel value has to be in the range of 1 "
                                                      "to 255!")
                         else:
                             if pixel < 16:

src/visualising/arduino.py

 #!/usr/bin/env python
 
 import time
+
 from visualising.message import FrameMsg, InstrMsg
 from visualising.animation import Animation
-from visualising.exception import ArduinoException
+from visualising.exception import VisualiseException
 
 
 class Arduino:
-    def __init__(self, connection):
-        self.connection = connection
 
-    # Translates a 8-bit message from Arduino and prints the translation.
-    @staticmethod
-    def print_response(msg):
-        arduino_msg = {
-            240: "A: -- ERROR -- Animation has to many frame ensembles!",
-            241: "A: -- ERROR -- No animation is loaded!",
-            242: "A: -- ERROR -- Instruction was not recognized!",
-            243: "A: -- ERROR -- No data message expected!",
-            244: "A: -- ERROR -- Message has wrong format!",
-            245: "A: -- ERROR -- Animation is playing!",
-            246: "A: -- ERROR -- Animation has no iteration!",
-            247: "A: -- ERROR -- Unequal number of frames for the left and right NeoPixel ring!",
-            248: "A: -- ERROR -- Animation has no frame ensemble!",
-            0: "A: No Response!",
-            15: "A: -- SUCCESS -- Waiting for frames to be send!",
-            31: "A: -- SUCCESS -- Animation playback has been started!",
-            47: "A: -- SUCCESS -- Frame successfully received!",
-            63: "A: -- SUCCESS -- Last frame successfully received!",
-            79: "A: -- SUCCESS -- Animation successfully played!",
-            95: "A: -- SUCCESS -- Animation playback has been paused!",
-            111: "A: -- SUCCESS -- Animation playback has been resumed",
-        }
+    source = "arduino.py"  # Name of the file that contains the Arduino class definition.
+    resend = 5             # Number of times a message is resend to the Arduino.
 
-        try:
-            print(arduino_msg[int.from_bytes(msg, byteorder='big')])
-        except KeyError:
-            raise ArduinoException("P: -- ERROR -- Unknown response from Arduino!")
+    def __init__(self, connection):
+        self.connection = connection
 
     # Creates one instruction messages and multiple frame messages to load an animation
     # onto the Arduino.
     def load_animation(self, animation):
         if animation.num_ensembles > 16:
-            raise ArduinoException("P: -- ERROR -- Animation hast to many frames!")
+            raise VisualiseException(source, "Animation hast to many frames!")
         else:
-            self.connection.send_msg(InstrMsg('A', animation).create_arduino_msg())
-            msg = self.connection.receive_msg()
+            try:
+                self.connection.confirm_msg(InstrMsg('A', animation).create_msg(), [b'\x0f'], resend)
+            except VisualiseException:
+                raise
 
-            Arduino.print_response(msg)
-            if bytes(msg) == bytes(b'\x0f'):
             for frame in animation.frames:
-                    self.connection.send_msg(FrameMsg(frame).create_arduino_msg())
-                    msg = self.connection.receive_msg()
-
-                    d = 10
-                    while bytes(msg) != bytes(b'\x2f') and bytes(msg) != bytes(b'\x3f') and d > 0:
-                        d = d - 1
-                        Arduino.print_response(msg)
-                        self.connection.send_msg(FrameMsg(frame).create_arduino_msg())
-                        msg = self.connection.receive_msg()
-
-                    if d > 0:
-                        Arduino.print_response(msg)
-                    else:
-                        raise ArduinoException("P: -- ERROR -- Unable to send frame message!")
+                try:
+                    self.connection.confirm_msg(FrameMsg(frame).create_msg(), [b'\x2f', b'\x3f'], resend)
+                except VisualiseException:
+                    raise
 
     # Creates instruction message and sends it to the Arduino,
     # to play a loaded animation.
     def start_playback(self):
-        self.connection.send_msg(InstrMsg('B').create_arduino_msg())
-        Arduino.print_response(self.connection.receive_msg())
+        try:
+            self.connection.confirm_msg(InstrMsg('B').create_msg(), [b'\x1f'], resend)
+        except VisualiseException:
+            raise
 
     # Creates instruction message and sends it to the Arduino,
     # to pause a playing animation.
     def pause_playback(self):
-        self.connection.send_msg(InstrMsg('C').create_arduino_msg())
-        Arduino.print_response(self.connection.receive_msg())
+        try:
+            self.connection.confirm_msg(InstrMsg('C').create_msg(), [b'\x5f'], resend)
+        except VisualiseException:
+            raise
 
     # Creates instruction message and sends it to the Arduino,
     # to resume playback of a loaded animation.
     def resume_playback(self):
-        self.connection.send_msg(InstrMsg('D').create_arduino_msg())
-        Arduino.print_response(self.connection.receive_msg())
+        try:
+            self.connection.confirm_msg(InstrMsg('D').create_msg(), [b'\x6f'], resend)
+        except VisualiseException:
+            raise
 
     # Streams an animation to the Arduino. For this purpose, two frames of
     # the animation are repeatedly sent to the Arduino. The Arduino plays

src/visualising/connection.py

@@ -3,33 +3,104 @@
 import time
 import serial
 
-from visualising.exception import ConnectionException
+from visualising.exception import VisualiseException
 from serial.serialutil import SerialException
 
 
 class Connection:
+
+    source = "connection.py"  # Name of the file that contains the Connection class definition.
+
     def __init__(self, port, baud):
         self.connection = serial.Serial()
         self.connection.port = port
         self.connection.baudrate = baud
         self.connection.timeout = 1
+
         try:
             self.connection.open()  # Establishes a serial connection.
         except SerialException:
-            raise ConnectionException("P: -- ERROR -- No serial connection established!")
+            raise VisualiseException(source, "No serial connection established!")
         except FileNotFoundError:
-            raise ConnectionException("P: -- ERROR -- The specified port does not exist!")
+            raise VisualiseException(source, "The specified port does not exist!")
 
         time.sleep(2)  # Prevents errors regarding pyserial.
 
-    # Send a message.
+    # Send a message to the Arduino.
     def send_msg(self, msg):
         for byte in msg:
             self.connection.write(byte)
         self.connection.reset_output_buffer()  # Clear serial output buffer.
 
-    # Receive a message.
+    # Receive a message from the Arduino.
     def receive_msg(self):
+        try:
+            # Since the timeout is set to one second, there is a waiting period of
+            # exactly one second to read a byte from the serial buffer. If no byte
+            # is read in this one second period, an exception is thrown.
             msg = self.connection.read(1)
+        except SerialException:  # Arduino has not responded in time.
+            msg = b'\xff'
+
         self.connection.reset_input_buffer()  # Clear serial input buffer.
         return msg
+
+    # Translates a 8-bit message from the Arduino.
+    @staticmethod
+    def translate_msg(msg):
+        translation = {
+            240: "Animation has to many frame ensembles!",                          # 0xF0
+            241: "No animation is loaded!",                                         # 0xF1
+            242: "Instruction was not recognized!",                                 # 0xF2
+            243: "No data message expected!",                                       # 0xF3
+            244: "Message has wrong format!",                                       # 0xF4
+            245: "Animation is playing!",                                           # 0xF5
+            246: "Animation has no iteration!",                                     # 0xF6
+            247: "Unequal number of frames for the left and right NeoPixel ring!",  # 0xF7
+            248: "Animation has no frame ensemble!",                                # 0xF8
+            255: "Timeout!",                                                        # 0xFF
+            0:   "No response!",                                                    # 0x00
+            15:  "Waiting for frames to be send!",                                  # 0x0F
+            31:  "Animation playback has been started!",                            # 0x1F
+            47:  "Frame successfully received!",                                    # 0x2F
+            63:  "Last frame successfully received!",                               # 0x3F
+            79:  "Animation successfully played!",                                  # 0x4F
+            95:  "Animation playback has been paused!",                             # 0x5F
+            111: "Animation playback has been resumed!",                            # 0x6F
+        }
+
+        try:
+            return translation[int.from_bytes(msg, byteorder='big')]
+        except KeyError:
+            return "Unknown response!"
+
+    # Send a message and confirm that the response is as expected.
+    # If the response is not as expected, try again as often as
+    # specified. In case any response wasn't even once one of the
+    # expected responses raise an exception.
+    def confirm_msg(self, msg, expected_responses, resend):
+        def evaluate():
+            bool = resend > 0
+            for element in expected_responses:
+                bool = bool and (bytes(element) != bytes(response))
+            return bool
+
+        if not isinstance(expected_responses, list):
+            raise VisualiseException(source, "Expected responses must be given as a list!")
+        elif not expected_responses:
+            raise VisualiseException(source, "There must be at least one expected response!")
+        elif not resend > 0:
+            raise VisualiseException(source, "Number of resends must be greater than zero!")
+        else:
+            self.connection.send_msg(msg)
+            response = self.connection.receive_msg()
+
+            condition = evaluate()
+            while condition:
+                resend = resend - 1
+                self.connection.send_msg(msg)
+                response = self.connection.receive_msg()
+                condition = evaluate()
+
+            if not resend > 0:
+                raise VisualiseException("Arduino", Connection.translate_msg(response))

src/visualising/exception.py

@@ -4,16 +4,7 @@ class Error(Exception):
     pass
 
 
-class AnimationException(Error):
-    def __init__(self, message):
-        self.message = message
-
-
-class ConnectionException(Error):
-    def __init__(self, message):
-        self.message = message
-
-
-class ArduinoException(Error):
-    def __init__(self, message):
-        self.message = message
+class VisualiseException(Error):
+    def __init__(self, source, description):
+        self.source = source
+        self.description = description

src/visualising/message.py

@@ -6,7 +6,7 @@ class FrameMsg:
 
     # Creates a 50-bit data Message. The first and last bit are intended for authentication
     # as a data message. The remaining 48 bits store exactly one animation frame.
-    def create_arduino_msg(self):
+    def create_msg(self):
         msg = [bytes('{', 'ascii')]
 
         for color in self.frame:
@@ -25,7 +25,7 @@ class InstrMsg:
     # Creates a 50-bit instruction message. Since only 7 bits at most are required for the
     # actual message, most of the message consists only of zeros. The first and last bit
     # are intended for authentication as an instruction message.
-    def create_arduino_msg(self):
+    def create_msg(self):
         msg = [bytes('[', 'ascii'), bytes(self.instr, 'ascii')]
 
         if self.animation is not None:

src/visualising/visualiser.py

 #!/usr/bin/env python
 
 import rospy
-from visualising.msg import State
-from visualising.msg import States
+from monitoring.watchdog import Watchdog
+from visualising.exception import *
 from visualising.arduino import Arduino
 from visualising.connection import Connection
 from visualising.animation import Animation
-from visualising.exception import *
 
 
 class Visualiser:
-    def __init__(self, port="/dev/ttyUSB0", baud=57600):
+    def __init__(self):
+        port = rospy.get_param("/arduino_port", "/dev/ttyUSB0")
+        baud = rospy.get_param("/arduino_baud", 57600)
+        self.visualisation_strategy = rospy.get_param("/visualisation_strategy", 1)
+
         self.arduino = Arduino(Connection(port, baud))
-        self.robot_state = 0  # Robot starts in a happy state.
+        self.watchdog = Watchdog()
 
-        self.happy = Animation(Animation.read_frames_from_file("animation_happy.txt"), 100, 1)
-        self.ok = Animation(Animation.read_frames_from_file("animation_ok.txt"), 100, 1)
-        self.sad = Animation(Animation.read_frames_from_file("animation_sad.txt"), 100, 1)
+    def visualise(self):
+        if self.visualisation_strategy == 1:
+            self.mood_mode()
+        elif self.visualisation_strategy == 2:
+            self.info_mode()
+        else:
+            rospy.logwarn("Visualiser: The specified strategy is not recognised by the visualiser!")
 
-        rospy.Subscriber("states", States, self.evaluate)
+    # TODO: Add all basic emotions!
+    def mood_mode(self):
+        happy = Animation(Animation.read_frames_from_file("animation_happy.txt"), 100, 1)
+        ok = Animation(Animation.read_frames_from_file("animation_ok.txt"), 100, 1)
+        sad = Animation(Animation.read_frames_from_file("animation_sad.txt"), 100, 1)
 
-        animation_duration = 1
-        self.timer = rospy.Timer(rospy.Duration(animation_duration), self.update_mood)
+        while not rospy.is_shutdown():
+            if self.watchdog.aggregated_domains > 0.7:
+                self.stream_animation(sad)
+            else:
+                if self.watchdog.aggregated_domains > 0.4:
+                    self.stream_animation(ok)
+                else:
+                    self.stream_animation(happy)
 
-    # TODO: Add different modes!
-    def evaluate(self, event):
-        number = 0
-        value = 0
 
-        for state in event.states:
-            value = value + state.critical
-            number = number + 1
 
-        self.robot_state = value / number
 
-    # TODO: Add different modes!
-    def update_mood(self, event):
-        print(self.robot_state)
-        if self.robot_state > 0.7:
-            self.stream_animation(self.sad)
-        else:
-            if self.robot_state > 0.4:
-                self.stream_animation(self.ok)
-            else:
-                self.stream_animation(self.happy)
+    def info_mode(self):
+        print("Hallo!")
 
     def stream_animation(self, animation):
         self.arduino.stream_animation(animation)
\ No newline at end of file