converting voltage to displacements

data_deserializer.py

@@ -159,7 +159,7 @@ def wrapper(messsage: MessageData):
                 if "data" in annotations:
                     kwargs["data"] = messsage.data[
                         obj["start_position"]
-                        - 1 : obj["start_position"]
+                        - 1: obj["start_position"]
                         + obj["length"]
                         - 1
                     ]

event.py

@@ -2,55 +2,55 @@
 import logging
 
 
-class parser():
+class Parser():
     def __init__(self, event: Event) -> None:
         self.event = event
-
-    def parse(self)-> Event:
-
-
-        if self.event["name"] == "linpot":
-            DataTransformer(self.event).handle_linpot()
-        name = self.event['name']
-        if self.event["name"] == "acclgyro":
-            DataTransformer(self.event).handle_acclgyro()
-        if self.event["name"] == "ecu":
-            DataTransformer(self.event).handle_ecu()
+
+    def parse(self) -> None:
+        try:
+            if self.event["name"] == "linpot":
+                DataTransformer(self.event).handle_linpot()
+            elif self.event["name"] == "accel":
+                DataTransformer(self.event).handle_acclgyro()
+            elif self.event["name"] == "gyro":
+                DataTransformer(self.event).handle_acclgyro()
+        except Exception as e:
+            logging.error("Error: %s, event not identifiable", e)
+
 
 class DataTransformer():
 
     def __init__(self, event: Event):
         self.event = event
 
-    def handle_linpot(self) -> Event:
+    def handle_linpot(self) -> LinpotEvent:
         """
         apply displacement calculations to the event fields.
         this method is to handle all linpot transformations specifically
         """
-        # for key in list of keys
         try:
             linpot_event = LinpotEvent(
-                FrontLeft=self.event.fields['front_left'],
-                FrontRight=self.event.fields['front_right'],
-                RearLeft=self.event.fields['rear_left'],
-                RearRight=self.event.fields['rear_right']
+                fields={
+                    'front_left': self.event.fields['front_left'],
+                    'front_right': self.event.fields['front_right'],
+                    'rear_left': self.event.fields['rear_left'],
+                    'rear_right': self.event.fields['rear_right']
+                },
+                name=self.event.name,
+                tags=self.event.tags,
+                timestamp=self.event.timestamp
             )
-            linpot_event.calculate_displacements_mm()
-        except KeyError as e:
-            logging.error("KeyError: %s", e)
+            displacement_object = linpot_event.calculate_displacements_mm(self.event)
+            return displacement_object
+
+        except Exception as e:
+            logging.error("Error: %s", e)
             logging.error("Fields: %s", self.event.fields)
-            return
+            return None
 
     def handle_acclgyro(self) -> Event:
         """
         apply acceleration calculations to the event fields.
         this method is to handle all acclgyro transformations specifically
         """
         pass
-
-    def handle_ecu(self) -> Event:
-        """
-        apply ecu calculations to the event fields.
-        this method is to handle all ecu transformations specifically
-        """
-        pass

function_app.py

@@ -1,5 +1,5 @@
 from event import DataTransformer as DT
-from event import parser as PS
+from event import Parser
 from datetime import datetime
 import azure.functions as func
 import logging
@@ -12,6 +12,7 @@
 import dns.resolver
 from can import Message
 from data_deserializer import MessageData
+from event import DataTransformer, Parser
 dns.resolver.default_resolver=dns.resolver.Resolver(configure=False)
 dns.resolver.default_resolver.nameservers=['8.8.8.8']
 
@@ -21,8 +22,8 @@
 
 @app.function_name("EventHubTrigger1")
 @app.event_hub_message_trigger(arg_name="azeventhub", event_hub_name="metricforwarder", cardinality="many",
-                               connection="metricsforward_metricmanager_EVENTHUB") 
-def eventhub_processor(azeventhub: func.EventHubEvent):    
+                               connection="metricsforward_metricmanager_EVENTHUB")
+def eventhub_processor(azeventhub: func.EventHubEvent):
     events = [json.loads(event.get_body().decode('utf-8')) for event in azeventhub]
 
     logging.info("Processing %d events; first event: %s", len(events), json.dumps(events[0], indent=3))
@@ -34,6 +35,9 @@ def eventhub_processor(azeventhub: func.EventHubEvent):
 
     # group all events that have the same event['tasg']
     for event in events:
+
+        Parser(event).parse()
+
         if event["tags"].get("source", "") == "ecu":
             arbitration_id = event["fields"].get("id", 0)
             raw_data = event["fields"].get("data", "")
@@ -46,9 +50,11 @@ def eventhub_processor(azeventhub: func.EventHubEvent):
             msg_data = MessageData(msg)
             try:
                 event["fields"] = json.loads(json.dumps(msg_data.to_dict(), default=str))
-            except Exception: # TODO: Make this a specific exception
+            except Exception:  # TODO: Make this a specific exception
                 logging.error("[ECU] Error converting to dict: %s", msg)
                 continue
+        elif event["tags"].get("source", "") == "linpot":
+
         tags = event['tags']
 
         # Call frozen set because we can't hash a dictionary
@@ -70,8 +76,8 @@ def eventhub_processor(azeventhub: func.EventHubEvent):
     post_data = {
         "streams": [
             {
-                "stream": {k:v for (k,v) in tags},
-                "values": [ # this stupid conversion to nanoseconds. Who tf does logs in nanoseconds
+                "stream": {k: v for (k, v) in tags},
+                "values": [  # this stupid conversion to nanoseconds. Who tf does logs in nanoseconds
                     [str(dump["timestamp"] * 1000000), json.dumps(dump['fields'], default=str)] for dump in dumps
                 ]
             } for tags, dumps in data.items()
@@ -94,10 +100,10 @@ def eventhub_processor(azeventhub: func.EventHubEvent):
     documents = []
     for doc in events:
         doc = {
-                "metadata": doc['tags'],
-                "timestamp": datetime.fromtimestamp(doc['timestamp'] / 1000),
-                **doc['fields']
-            }
+            "metadata": doc['tags'],
+            "timestamp": datetime.fromtimestamp(doc['timestamp'] / 1000),
+            **doc['fields']
+        }
         # validate timestamp because they suck
         if doc['timestamp'] > datetime.now() or doc['timestamp'] < datetime(2020, 1, 1):
             logging.error("Invalid timestamp: %s", doc['timestamp'])

models.py

@@ -20,20 +20,31 @@ class LinpotEvent(BaseModel):
     '''
     Class for keeping track of linpot event data
     '''
-    # TODO rename the values for front left, front right, rear left, rear right and so on to not have spaces
     front_left: float
     front_right: float
     rear_left: float
     rear_right: float
 
-    def calculate_displacements_mm(self):
-        for key in ["Front Left", "Front Right", "Rear Left", "Rear Right"]:
-            # updating the lin pot values in place
+    def calculate_displacements_mm(self, event: Event)-> Event:
+        """calcualtes displacements in mm from linpot values
+
+        Returns:
+            dict: displacements in mm
+        """
+
+        displacements = {}
+        linpots = ["front_left", "front_right", "rear_left", "rear_right"]
+
+        for key in linpots:
             current_value = getattr(self, key)
-            new_value = -(current_value * LINPOT_CONVERSION_CONSTANT) + LINPOT_CONVERSION_OFFSET
-            setattr(self, key, new_value)
+            converted_to_mm = -(current_value * LINPOT_CONVERSION_CONSTANT) + LINPOT_CONVERSION_OFFSET
+            displacements[key] = converted_to_mm
 
-    def calculate_wheel_loads():
+        event.fields.update(displacements)
+
+        return event
+
+    def calculate_wheel_loads(self):
         pass
 
 
@@ -44,7 +55,6 @@ class AccelGyroEvent(BaseModel):
     def calculate_gforce():
         pass
 
-    pass
 
 
 class ECUEvent(BaseModel):