Merge pull request #156 from openxc/regenproto

Regenerated the Python protobuf file and fixed glue file binary to pr…

Author: GenoJAFord

openxc/controllers/base.py

@@ -90,7 +90,10 @@ def handle_responses(self):
                             else:
                                 self.diag_dict[response['id']] = MultiframeDiagnosticMessage(response)
                             if self._return_final(response):
-                                self.responses.append(self.diag_dict[response['id']].getResponse())
+                                save = self.responses.pop()
+                                dentry = self.diag_dict[response['id']].getResponse()  # DO NOT REMOVE This MUST be saved to a local variable to prevent deallocation
+                                self.responses.append(dentry)                          # DO NOT REMOVE This MUST be saved to a local variable to prevent deallocation
+                                self.responses.append(save)
                                 self.diag_dict.pop(response['id'])
                     self.responses.append(response)
                     if self.quit_after_first:
@@ -101,14 +104,14 @@ def handle_responses(self):
 
 class MultiframeDiagnosticMessage:
     def __init__(self, response):
-        self.id = response['id'] - 16
+        self.id = response['id']
         self.mode = response['mode']
         self.bus = response['bus']
         self.pid = response['pid']
         self.payload = '0x' + response['payload'][8:]
 
     def addFrame(self, response):
-        self.payload += response['payload'][8:]
+        self.payload += response['payload'][2:]
 
     def getResponse(self):
         request = {
@@ -132,6 +135,7 @@ def _response_matches_request(self, response):
         original request.
         """
         return response.get('command_response', None) == self.request['command']
+        ##return True
 
 class DiagnosticResponseReceiver(ResponseReceiver):
     """A receiver that matches the bus, ID, mode and PID from a
@@ -170,8 +174,12 @@ def _response_matches_request(self, response):
         return response.get('mode', None) == self.diagnostic_request['mode']
 
     def _response_is_multiframe(self, response):
-        if 'frame' in response:
-            return True
+        #if 'frame' in response:
+        #    return True
+        print(response)
+        if 'total_size' in response.keys():
+            if response["total_size"] > 0:
+                return True
         return False
 
     def _return_final(self, response):

openxc/formats/base.py

@@ -3,8 +3,6 @@ class VehicleMessageStreamer(object):
     bytes_received = 0
 
     def receive(self, payload):
-        if not isinstance(payload, bytes):
-            payload = payload.encode("utf-8")
         if len(payload) > 0:
             self.message_buffer += payload
             self.bytes_received += len(payload)

openxc/formats/binary.py

@@ -126,7 +126,8 @@ def _handle_diagnostic_cc_message(cls, data, message):
             request_command.action = openxc_pb2.DiagnosticControlCommand.CANCEL
         request = request_command.request
         request_data = data['request']
-        request.bus = request_data['bus']
+        if 'bus' in request_data:
+            request.bus = request_data['bus']
         request.message_id = request_data['id']
         request.mode = request_data['mode']
         if 'frequency' in request_data:
@@ -184,6 +185,10 @@ def _build_diagnostic_message(cls, data, message):
         response.bus = data['bus']
         response.message_id = data['id']
         response.mode = data['mode']
+        if 'total_size' in data:
+            response.total_size = data['total_size']
+        if 'frame' in data:
+            response.frame = data['frame']
         if 'pid' in data:
             response.pid = data['pid']
         if 'success' in data:
@@ -243,63 +248,57 @@ def _dict_to_protobuf(cls, data):
     @classmethod
     def _build_can_parsed_message(cls, message, parsed_message):
         can_message = message.can_message
-        if can_message.HasField('bus'):
+        if can_message.bus != 0:
             parsed_message['bus'] = can_message.bus
-        if can_message.HasField('id'):
+        if can_message.id != 0:
             parsed_message['id'] = can_message.id
-        if can_message.HasField('data'):
+        if len(binascii.hexlify(can_message.data).decode("ascii")) > 0:
             parsed_message['data'] = "0x%s" % binascii.hexlify(can_message.data).decode("ascii")
-        if can_message.HasField('frame_format'):
-            if can_message.frame_format == openxc_pb2.CanMessage.STANDARD:
-                parsed_message['frame_format'] = "standard"
-            elif can_message.frame_format == openxc_pb2.CanMessage.EXTENDED:
-                parsed_message['frame_format'] = "extended"
+        if can_message.frame_format == openxc_pb2.CanMessage.STANDARD:
+            parsed_message['frame_format'] = "standard"
+        elif can_message.frame_format == openxc_pb2.CanMessage.EXTENDED:
+            parsed_message['frame_format'] = "extended"
 
     @classmethod
     def _build_diagnostic_parsed_message(cls, message, parsed_message):
         diagnostic_message = message.diagnostic_response
-        if diagnostic_message.HasField('bus'):
+        if diagnostic_message.bus != 0:
             parsed_message['bus'] = diagnostic_message.bus
-        if diagnostic_message.HasField('message_id'):
+        if diagnostic_message.message_id != 0:
             parsed_message['id'] = diagnostic_message.message_id
-        if diagnostic_message.HasField('mode'):
-            parsed_message['mode'] = diagnostic_message.mode
-        if diagnostic_message.HasField('pid'):
-            parsed_message['pid'] = diagnostic_message.pid
-        if diagnostic_message.HasField('success'):
-            parsed_message['success'] = diagnostic_message.success
-        if diagnostic_message.HasField('value'):
+        parsed_message['mode'] = diagnostic_message.mode
+        parsed_message['pid'] = diagnostic_message.pid
+        if diagnostic_message.total_size != 0:
+            parsed_message['total_size'] = diagnostic_message.total_size
+        parsed_message['frame'] = diagnostic_message.frame
+        parsed_message['success'] = diagnostic_message.success
+        if diagnostic_message.value.type != openxc_pb2.DynamicField.UNUSED:     ##GJA
             parsed_message['value'] = diagnostic_message.value
-        if diagnostic_message.HasField('negative_response_code'):
+        if diagnostic_message.negative_response_code !=0:
             parsed_message['negative_response_code'] = diagnostic_message.negative_response_code
-        if diagnostic_message.HasField('payload'):
+        if len(binascii.hexlify(diagnostic_message.payload).decode("ascii")) > 0:
             parsed_message['payload'] = "0x%s" % binascii.hexlify(diagnostic_message.payload).decode("ascii")
 
     @classmethod
     def _build_simple_parsed_message(cls, message, parsed_message):
         simple_message = message.simple_message
         parsed_message['name'] = simple_message.name
-        if simple_message.HasField('event'):
-            event = simple_message.event
-            if event.HasField('numeric_value'):
-                parsed_message['event'] = event.numeric_value
-            elif event.HasField('boolean_value'):
-                parsed_message['event'] = event.boolean_value
-            elif event.HasField('string_value'):
-                parsed_message['event'] = event.string_value
-
-        if simple_message.HasField('value'):
-            value = simple_message.value
-            if value.HasField('numeric_value'):
-                parsed_message['value'] = value.numeric_value
-            elif value.HasField('boolean_value'):
-                parsed_message['value'] = value.boolean_value
-            elif value.HasField('string_value'):
-                parsed_message['value'] = value.string_value
-            else:
-                parsed_message = None
+        event = simple_message.event
+        if (len(event.string_value) > 0):
+            parsed_message['event'] = event.string_value
+        elif event.numeric_value != 0:
+            parsed_message['event'] = event.numeric_value
         else:
-            parsed_message = None
+            parsed_message['event'] = event.boolean_value
+
+        value = simple_message.value
+        if (len(value.string_value) > 0):
+            parsed_message['value'] = value.string_value
+        elif value.numeric_value != 0:
+            parsed_message['value'] = value.numeric_value
+        else:
+            parsed_message['value'] = value.boolean_value
+
 
     @classmethod
     def _handle_diagnostic_cc_parsed_message(cls, command, parsed_message):
@@ -316,16 +315,16 @@ def _handle_diagnostic_cc_parsed_message(cls, command, parsed_message):
         parsed_message['request']['bus'] = request.bus
         parsed_message['request']['mode'] = request.mode
 
-        if request.HasField('frequency'):
+        if request.frequency != 0:
             parsed_message['request']['frequency'] = request.frequency
-        if request.HasField('name'):
+        if len(request.name) > 0:
             parsed_message['request']['name'] = request.name
-        if request.HasField('multiple_responses'):
-            parsed_message['request']['multiple_responses'] = request.multiple_responses
-        if request.HasField('pid'):
+        parsed_message['request']['multiple_responses'] = request.multiple_responses
+        if request.pid != 0:
             parsed_message['request']['pid'] = request.pid
-        if request.HasField('payload'):
+        if len(binascii.hexlify(request.payload).decode("ascii")) > 0:
             parsed_message['request']['payload'] = "0x%s" % binascii.hexlify(request.payload).decode("ascii")
+        print("Finished _handle_diagnostic_cc_parsed_message")
 
     @classmethod
     def _handle_passthrough_cc_parsed_message(cls, command, parsed_message):
@@ -393,14 +392,14 @@ def _build_command_response_parsed_message(cls, message, parsed_message):
             raise UnrecognizedBinaryCommandError(response.type)
 
         parsed_message['status'] = response.status
-        if response.HasField('message'):
+        if len(response.message) > 0:
             parsed_message['message'] = response.message
 
     @classmethod
     def _protobuf_to_dict(cls, message):
         parsed_message = {}
         if message is not None:
-            if message.type == message.CAN and message.HasField('can_message'):
+            if message.type == message.CAN:
                 cls._build_can_parsed_message(message, parsed_message)
             elif message.type == message.DIAGNOSTIC:
                 cls._build_diagnostic_parsed_message(message, parsed_message)