├── .gitignore ├── benchmark └── proto │ ├── .gitignore │ └── compare_sizes.py ├── pip-requirements.txt ├── gen ├── cpp │ ├── openxc.pb │ ├── openxc.pb.c │ └── openxc.pb.h ├── README.mkd ├── python │ └── openxc_pb2.py └── go │ └── openxc.pb.go ├── .gitmodules ├── Makefile ├── openxc.options ├── LICENSE ├── CHANGELOG.md ├── openxc.proto ├── script └── bootstrap.sh ├── README.md └── JSON.mkd /.gitignore: -------------------------------------------------------------------------------- 1 | *~ 2 | -------------------------------------------------------------------------------- /benchmark/proto/.gitignore: -------------------------------------------------------------------------------- 1 | *_pb2.py 2 | -------------------------------------------------------------------------------- /pip-requirements.txt: -------------------------------------------------------------------------------- 1 | protobuf==3.0.0 2 | -------------------------------------------------------------------------------- /gen/cpp/openxc.pb: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/openxc/openxc-message-format/HEAD/gen/cpp/openxc.pb -------------------------------------------------------------------------------- /.gitmodules: -------------------------------------------------------------------------------- 1 | [submodule "libs/nanopb"] 2 | path = libs/nanopb 3 | url = https://github.com/nanopb/nanopb 4 | -------------------------------------------------------------------------------- /Makefile: -------------------------------------------------------------------------------- 1 | nanopb: proto 2 | make -C libs/nanopb/generator/proto 3 | python libs/nanopb/generator/nanopb_generator.py gen/cpp/openxc.pb -f openxc.options 4 | 5 | proto: openxc.proto 6 | @mkdir -p gen/java 7 | @mkdir -p gen/python 8 | @mkdir -p gen/cpp 9 | protoc -I . -I gen -ogen/cpp/openxc.pb --python_out=gen/python --java_out=gen/java $? 10 | 11 | all: nanopb proto 12 | -------------------------------------------------------------------------------- /openxc.options: -------------------------------------------------------------------------------- 1 | openxc.SimpleMessage.name max_size:100 2 | openxc.DynamicField.string_value max_size:128 3 | openxc.CommandResponse.message max_size:128 4 | openxc.DiagnosticResponse.payload max_size:255 5 | openxc.DiagnosticRequest.name max_size:10 6 | openxc.DiagnosticRequest.payload max_size:8 7 | openxc.CanMessage.data max_size:8 8 | 9 | openxc.ServerConnectSettings.host max_size:128 10 | openxc.NetworkDataSettings.apn max_size:64 11 | -------------------------------------------------------------------------------- /gen/README.mkd: -------------------------------------------------------------------------------- 1 | Generated Files 2 | ================ 3 | 4 | This directory holds generated implementation files for the Protocol Buffer 5 | objects defined in openxc.proto. The definitions don't change very often, and so 6 | it makes more sense to keep a compiled version in the repository for each 7 | major build environment rather than requiring each developer to get the protobuf 8 | dependencies. 9 | 10 | I've also not found a good way to incorporate protobuf generation with our 11 | Makefile build system in the openxc/vi-firmware project. 12 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | Copyright (c) 2012 Ford Motor Company 2 | All rights reserved. 3 | 4 | Redistribution and use in source and binary forms, with or without 5 | modification, are permitted provided that the following conditions are met: 6 | * Redistributions of source code must retain the above copyright 7 | notice, this list of conditions and the following disclaimer. 8 | * Redistributions in binary form must reproduce the above copyright 9 | notice, this list of conditions and the following disclaimer in the 10 | documentation and/or other materials provided with the distribution. 11 | * Neither the name of the nor the 12 | names of its contributors may be used to endorse or promote products 13 | derived from this software without specific prior written permission. 14 | 15 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 16 | ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 17 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 18 | DISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY 19 | DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 20 | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 21 | LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 22 | ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 23 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 24 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 25 | -------------------------------------------------------------------------------- /gen/cpp/openxc.pb.c: -------------------------------------------------------------------------------- 1 | /* Automatically generated nanopb constant definitions */ 2 | /* Generated by nanopb-0.4.0-dev */ 3 | 4 | #include "openxc.pb.h" 5 | 6 | /* @@protoc_insertion_point(includes) */ 7 | #if PB_PROTO_HEADER_VERSION != 40 8 | #error Regenerate this file with the current version of nanopb generator. 9 | #endif 10 | 11 | PB_BIND(openxc_VehicleMessage, openxc_VehicleMessage, 2) 12 | 13 | 14 | PB_BIND(openxc_CanMessage, openxc_CanMessage, AUTO) 15 | 16 | 17 | PB_BIND(openxc_ControlCommand, openxc_ControlCommand, 2) 18 | 19 | 20 | PB_BIND(openxc_DiagnosticControlCommand, openxc_DiagnosticControlCommand, AUTO) 21 | 22 | 23 | PB_BIND(openxc_PassthroughModeControlCommand, openxc_PassthroughModeControlCommand, AUTO) 24 | 25 | 26 | PB_BIND(openxc_AcceptanceFilterBypassCommand, openxc_AcceptanceFilterBypassCommand, AUTO) 27 | 28 | 29 | PB_BIND(openxc_PayloadFormatCommand, openxc_PayloadFormatCommand, AUTO) 30 | 31 | 32 | PB_BIND(openxc_PredefinedObd2RequestsCommand, openxc_PredefinedObd2RequestsCommand, AUTO) 33 | 34 | 35 | PB_BIND(openxc_NetworkOperatorSettings, openxc_NetworkOperatorSettings, AUTO) 36 | 37 | 38 | PB_BIND(openxc_NetworkOperatorSettings_NetworkDescriptor, openxc_NetworkOperatorSettings_NetworkDescriptor, AUTO) 39 | 40 | 41 | PB_BIND(openxc_NetworkDataSettings, openxc_NetworkDataSettings, AUTO) 42 | 43 | 44 | PB_BIND(openxc_ServerConnectSettings, openxc_ServerConnectSettings, AUTO) 45 | 46 | 47 | PB_BIND(openxc_ModemConfigurationCommand, openxc_ModemConfigurationCommand, AUTO) 48 | 49 | 50 | PB_BIND(openxc_RTCConfigurationCommand, openxc_RTCConfigurationCommand, AUTO) 51 | 52 | 53 | PB_BIND(openxc_CommandResponse, openxc_CommandResponse, AUTO) 54 | 55 | 56 | PB_BIND(openxc_DiagnosticRequest, openxc_DiagnosticRequest, AUTO) 57 | 58 | 59 | PB_BIND(openxc_DiagnosticResponse, openxc_DiagnosticResponse, 2) 60 | 61 | 62 | PB_BIND(openxc_DynamicField, openxc_DynamicField, AUTO) 63 | 64 | 65 | PB_BIND(openxc_SimpleMessage, openxc_SimpleMessage, 2) 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | /* On some platforms (such as AVR), double is really float. 79 | * Using double on these platforms is not directly supported 80 | * by nanopb, but see example_avr_double. 81 | * To get rid of this error, remove any double fields from your .proto. 82 | */ 83 | PB_STATIC_ASSERT(sizeof(double) == 8, DOUBLE_MUST_BE_8_BYTES) 84 | 85 | /* @@protoc_insertion_point(eof) */ 86 | -------------------------------------------------------------------------------- /CHANGELOG.md: -------------------------------------------------------------------------------- 1 | # OpenXC Message Format Changelog 2 | 3 | ## v0.8.0 4 | 5 | * Feature: Support for GET_VIN command 6 | * Improvements: Diagnostic Request structure enhanced to handle stitch frames 7 | * Removed: MessagePack encoding removed 8 | 9 | ## v0.7.0-dev 10 | 11 | * Improvement: Increase diagnostic response payload size to accommodate 12 | multi-frame diagnostic responses. 13 | * Feature: Added control command to get device's platform 14 | 15 | ## v0.6.0 16 | 17 | * Feature: Added MessagePack support for BTLE connections. 18 | * Feature: Support for vehicle message timestamps (changed previous uptime). 19 | * Feature: Support for C5 SD Card. 20 | * Feature: Support for C5 RTC. 21 | * Fix: Update submodule from code.google to github. 22 | 23 | ## v0.5.0 24 | 25 | * Feature: Support for C5 Cellular device. New uptime message. 26 | 27 | ## v0.4 28 | 29 | * BREAKING: Removed factor and offset from diagnostic requests to minimize the number of 30 | fields, and since this is such an uncommon use case and one that can be 31 | handled by the client receiving the data. We may add them back in the future. 32 | * BREAKING: Require an 'action' to diagnostic request commands, e.g. cancel or add. 33 | * BREAKING: Rename "raw" messages to the more precise "CAN messages". 34 | * BREAKING: Rename "translated" messages to "simple messages". 35 | * BREAKING: Remove redundant `type` field from simple messages (formerly 36 | translated messages). The type can be inferred implicitly through the types of 37 | the value and event fields. 38 | * Feature: Add a command for controlling CAN message passthrough. 39 | * Feature: Add a command for controlling CAN controller acceptance filter bypass. 40 | * Feature: Add a command to change the payload format. 41 | * Feature: Add a command to control whether pre-defined, recurring OBD-II 42 | requests are enabled. 43 | * Improvement: Add `extras` field to JSON messages. 44 | * Improvement: Add an optional 'status' field to all command responses. 45 | * Improvement: Build protobuf generated files with nanopb v0.3.1. 46 | * Improvement: Allow explicitly setting CAN message frame format (i.e. standard 47 | or extended frame). 48 | * Fix: Expand range of mode field to a full byte (#10) 49 | 50 | ## v0.3 51 | 52 | * Add diagnostic message request/response format. 53 | * Officially add Protcol Buffer encoding. 54 | * Change JSON delimiter to ```\0``` for both input and output. 55 | * Officially document version and device ID commands. 56 | 57 | ## v0.2 58 | 59 | * Add a RAW can message format. 60 | 61 | ## v0.1 62 | 63 | * Initial release. 64 | -------------------------------------------------------------------------------- /openxc.proto: -------------------------------------------------------------------------------- 1 | syntax = "proto3"; 2 | 3 | package openxc; 4 | 5 | option java_package = "com.openxc"; 6 | option java_outer_classname = "BinaryMessages"; 7 | 8 | message VehicleMessage { 9 | enum Type { UNUSED = 0; CAN = 1; SIMPLE = 2; DIAGNOSTIC = 3; CONTROL_COMMAND = 4; 10 | COMMAND_RESPONSE = 5; } 11 | 12 | Type type = 1; 13 | CanMessage can_message = 2; 14 | SimpleMessage simple_message = 3; 15 | DiagnosticResponse diagnostic_response = 4; 16 | ControlCommand control_command = 5; 17 | CommandResponse command_response = 6; 18 | uint64 timestamp = 7; 19 | } 20 | 21 | message CanMessage { 22 | enum FrameFormat { 23 | UNUSED = 0; 24 | STANDARD = 1; 25 | EXTENDED = 2; 26 | } 27 | int32 bus = 1; 28 | uint32 id = 2; 29 | bytes data = 3; 30 | FrameFormat frame_format = 4; 31 | } 32 | 33 | message ControlCommand { 34 | enum Type { 35 | UNUSED = 0; 36 | VERSION = 1; 37 | DEVICE_ID = 2; 38 | DIAGNOSTIC = 3; 39 | PASSTHROUGH = 4; 40 | ACCEPTANCE_FILTER_BYPASS = 5; 41 | PAYLOAD_FORMAT = 6; 42 | PREDEFINED_OBD2_REQUESTS = 7; 43 | MODEM_CONFIGURATION = 8; 44 | RTC_CONFIGURATION = 9; 45 | SD_MOUNT_STATUS = 10; 46 | PLATFORM = 11; 47 | GET_VIN = 12; 48 | } 49 | 50 | Type type = 1; 51 | DiagnosticControlCommand diagnostic_request = 2; 52 | PassthroughModeControlCommand passthrough_mode_request = 3; 53 | AcceptanceFilterBypassCommand acceptance_filter_bypass_command = 4; 54 | PayloadFormatCommand payload_format_command = 5; 55 | PredefinedObd2RequestsCommand predefined_obd2_requests_command = 6; 56 | ModemConfigurationCommand modem_configuration_command = 7; 57 | RTCConfigurationCommand rtc_configuration_command = 8; 58 | } 59 | 60 | message DiagnosticControlCommand { 61 | enum Action { UNUSED = 0; ADD = 1; CANCEL = 2; } 62 | 63 | DiagnosticRequest request = 1; 64 | Action action = 2; 65 | } 66 | 67 | message PassthroughModeControlCommand { 68 | int32 bus = 1; 69 | bool enabled = 2; 70 | } 71 | 72 | message AcceptanceFilterBypassCommand { 73 | int32 bus = 1; 74 | bool bypass = 2; 75 | } 76 | 77 | message PayloadFormatCommand { 78 | enum PayloadFormat { 79 | UNUSED = 0; 80 | JSON = 1; 81 | PROTOBUF = 2; 82 | } 83 | 84 | PayloadFormat format = 1; 85 | } 86 | 87 | message PredefinedObd2RequestsCommand { 88 | bool enabled = 1; 89 | } 90 | 91 | message NetworkOperatorSettings { 92 | enum OperatorSelectMode { 93 | AUTOMATIC = 0; 94 | MANUAL = 1; 95 | DEREGISTER = 2; 96 | SET_ONLY = 3; 97 | MANUAL_AUTOMATIC = 4; 98 | } 99 | message NetworkDescriptor { 100 | enum NetworkType { 101 | GSM = 0; 102 | UTRAN = 2; 103 | } 104 | uint32 PLMN = 1; 105 | NetworkType networkType = 2; 106 | } 107 | bool allowDataRoaming = 1; 108 | OperatorSelectMode operatorSelectMode = 2; 109 | NetworkDescriptor networkDescriptor = 3; 110 | } 111 | 112 | message NetworkDataSettings { 113 | string apn = 1; 114 | } 115 | 116 | message ServerConnectSettings { 117 | string host = 1; 118 | uint32 port = 2; 119 | } 120 | 121 | message ModemConfigurationCommand { 122 | NetworkOperatorSettings networkOperatorSettings = 1; 123 | NetworkDataSettings networkDataSettings = 2; 124 | ServerConnectSettings serverConnectSettings = 3; 125 | } 126 | 127 | message RTCConfigurationCommand { 128 | uint32 unix_time = 1; 129 | } 130 | 131 | message CommandResponse { 132 | ControlCommand.Type type = 1; 133 | string message = 2; 134 | bool status = 3; 135 | } 136 | 137 | message DiagnosticRequest { 138 | enum DecodedType { UNUSED = 0; NONE = 1; OBD2 = 2; } 139 | 140 | int32 bus = 1; 141 | uint32 message_id = 2; 142 | uint32 mode = 3; 143 | uint32 pid = 4; 144 | bytes payload = 5; 145 | bool multiple_responses = 6; 146 | double frequency = 7; 147 | string name = 8; 148 | DecodedType decoded_type = 9; 149 | } 150 | 151 | message DiagnosticResponse { 152 | int32 bus = 1; 153 | uint32 message_id = 2; 154 | uint32 mode = 3; 155 | uint32 pid = 4; 156 | bool success = 5; 157 | uint32 negative_response_code = 6; 158 | bytes payload = 7; 159 | DynamicField value = 8; 160 | int32 frame = 9; 161 | uint32 total_size = 10; 162 | } 163 | 164 | message DynamicField { 165 | enum Type { UNUSED = 0; STRING = 1; NUM = 2; BOOL = 3; } 166 | 167 | Type type = 1; 168 | string string_value = 2; 169 | double numeric_value = 3; 170 | bool boolean_value = 4; 171 | } 172 | 173 | message SimpleMessage { 174 | string name = 1; 175 | DynamicField value = 2; 176 | DynamicField event = 3; 177 | } 178 | -------------------------------------------------------------------------------- /benchmark/proto/compare_sizes.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | 3 | from __future__ import division 4 | import sys 5 | import numbers 6 | 7 | import openxc_pb2 8 | import json 9 | 10 | def sizeof_fmt(num): 11 | for unit in ['bytes', 'KB', 'MB', 'GB', 'TB']: 12 | if num < 1024.0: 13 | return "%3.1f%s" % (num, unit) 14 | num /= 1024.0 15 | 16 | total_raw_can_size = 0 17 | total_raw_json_size = 0 18 | total_raw_binary_size = 0 19 | total_translated_json_size = 0 20 | total_translated_binary_size = 0 21 | 22 | for trace_file in sys.argv[1:]: 23 | for line in open(trace_file): 24 | try: 25 | json_message = json.loads(line) 26 | except ValueError: 27 | continue 28 | 29 | del json_message['timestamp'] 30 | 31 | message = openxc_pb2.VehicleMessage() 32 | 33 | if 'id' and 'data' in json_message: 34 | # rough approx. that CAN messages are 10 bytes - they could be less 35 | # but most of ours are full 64+11 bits 36 | total_raw_can_size += 10 37 | total_raw_json_size += len(json.dumps(json_message)) 38 | message.type = openxc_pb2.VehicleMessage.RAW 39 | message.raw_message.message_id = json_message['id'] 40 | message.raw_message.data = int(json_message['data'], 0) 41 | total_raw_binary_size += len(message.SerializeToString()) 42 | else: 43 | message.type = openxc_pb2.VehicleMessage.TRANSLATED 44 | message.translated_message.name = json_message['name'] 45 | if 'event' in json_message: 46 | message.translated_message.string_value = json_message['value'] 47 | if isinstance(json_message['event'], bool): 48 | message.translated_message.type = openxc_pb2.TranslatedMessage.EVENTED_BOOL 49 | message.translated_message.boolean_event = json_message['event'] 50 | elif isinstance(json_message['event'], numbers.Number): 51 | message.translated_message.type = openxc_pb2.TranslatedMessage.EVENTED_NUM 52 | message.translated_message.numeric_value = json_message['event'] 53 | else: 54 | message.translated_message.type = openxc_pb2.TranslatedMessage.EVENTED_STRING 55 | message.translated_message.string_value = json_message['event'] 56 | else: 57 | if isinstance(json_message['value'], bool): 58 | message.translated_message.type = openxc_pb2.TranslatedMessage.BOOL 59 | message.translated_message.boolean_value = json_message['value'] 60 | elif isinstance(json_message['value'], numbers.Number): 61 | message.translated_message.type = openxc_pb2.TranslatedMessage.NUM 62 | message.translated_message.numeric_value = json_message['value'] 63 | else: 64 | message.translated_message.type = openxc_pb2.TranslatedMessage.STRING 65 | message.translated_message.string_value = json_message['value'] 66 | total_translated_json_size += len(json.dumps(json_message)) 67 | total_translated_binary_size += len(message.SerializeToString()) 68 | 69 | 70 | print("For the %d trace files given..." % len(sys.argv[1:])) 71 | print("Total transferred raw CAN size is %s" % sizeof_fmt(total_raw_can_size)) 72 | print("Total transferred raw JSON size is %s" % sizeof_fmt(total_raw_json_size)) 73 | print("Total transferred raw binary size is %s" % sizeof_fmt(total_raw_binary_size)) 74 | print("Total transferred translated JSON size is %s" % 75 | sizeof_fmt(total_translated_json_size)) 76 | print("Total transferred translated binary size is %s" % 77 | sizeof_fmt(total_translated_binary_size)) 78 | 79 | total_json_size = total_raw_json_size + total_translated_json_size 80 | print("Total transferred JSON size is %s" % sizeof_fmt(total_json_size)) 81 | total_binary_size = total_raw_binary_size + total_translated_binary_size 82 | print("Total transferred binary size is %s" % sizeof_fmt(total_binary_size)) 83 | 84 | if total_raw_can_size > 0: 85 | print("Binary encoding adds %f%% overhead to raw CAN messages" % ( 86 | total_raw_binary_size / total_raw_can_size * 100 - 100)) 87 | print("JSON encoding adds %f%% overhead to raw CAN messages" % ( 88 | total_raw_json_size / total_raw_can_size * 100 - 100)) 89 | if total_raw_json_size > 0: 90 | print("Binary encoding is %f%% smaller than JSON for raw messages" % ( 91 | 100 - (total_raw_binary_size / total_raw_json_size * 100))) 92 | if total_translated_json_size > 0: 93 | print("Binary encoding is %f%% smaller than JSON for translated messages" % ( 94 | 100 - (total_translated_binary_size / total_translated_json_size * 100))) 95 | print("Binary encoding is %f%% smaller than JSON overall" % ( 96 | 100 - (total_binary_size / total_json_size * 100))) 97 | -------------------------------------------------------------------------------- /script/bootstrap.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | set -e 4 | 5 | DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )" 6 | pushd $DIR/.. 7 | 8 | # TODO this is kind of a hacky way of determining if root is required - 9 | # ideally we wouuld set up a little virtualenv in the dependencies folder 10 | SUDO_CMD= 11 | if command -v sudo >/dev/null 2>&1; then 12 | SUDO_CMD="sudo -E" 13 | 14 | echo "The bootstrap script needs to install a few packages to your system as an admin, and we will use the 'sudo' command - enter your password to continue" 15 | $SUDO_CMD ls > /dev/null 16 | fi 17 | 18 | KERNEL=`uname` 19 | if [ ${KERNEL:0:7} == "MINGW32" ]; then 20 | OS="windows" 21 | elif [ ${KERNEL:0:6} == "CYGWIN" ]; then 22 | OS="cygwin" 23 | elif [ $KERNEL == "Darwin" ]; then 24 | OS="mac" 25 | else 26 | OS="linux" 27 | if ! command -v lsb_release >/dev/null 2>&1; then 28 | # Arch Linux 29 | if command -v pacman>/dev/null 2>&1; then 30 | $SUDO_CMD pacman -S lsb-release 31 | fi 32 | fi 33 | 34 | DISTRO=`lsb_release -si` 35 | fi 36 | 37 | die() { 38 | echo >&2 "${bldred}$@${txtrst}" 39 | exit 1 40 | } 41 | 42 | _cygwin_error() { 43 | echo 44 | echo "${bldred}Missing \"$1\"${txtrst} - run the Cygwin installer again and select the base package set:" 45 | echo " $CYGWIN_PACKAGES" 46 | echo "After installing the packages, re-run this bootstrap script." 47 | die 48 | } 49 | 50 | if ! command -v tput >/dev/null 2>&1; then 51 | if [ $OS == "cygwin" ]; then 52 | echo "OPTIONAL: Install the \"ncurses\" package in Cygwin to get colored shell output" 53 | fi 54 | else 55 | txtrst=$(tput sgr0) # reset 56 | bldred=${txtbld}$(tput setaf 1) 57 | bldgreen=${txtbld}$(tput setaf 2) 58 | fi 59 | 60 | _pushd() { 61 | pushd $1 > /dev/null 62 | } 63 | 64 | _popd() { 65 | popd > /dev/null 66 | } 67 | 68 | _wait() { 69 | if [ -z $CI ]; then 70 | echo "Press Enter when done" 71 | read 72 | fi 73 | } 74 | 75 | _install() { 76 | if [ $OS == "cygwin" ]; then 77 | _cygwin_error $1 78 | elif [ $OS == "mac" ]; then 79 | # brew exists with 1 if it's already installed 80 | set +e 81 | brew install $1 82 | set -e 83 | else 84 | if [ -z $DISTRO ]; then 85 | echo 86 | echo "Missing $1 - install it using your distro's package manager or build from source" 87 | _wait 88 | else 89 | if [ $DISTRO == "arch" ]; then 90 | $SUDO_CMD pacman -S $1 91 | elif [ $DISTRO == "Ubuntu" ]; then 92 | $SUDO_CMD apt-get update -qq 93 | $SUDO_CMD apt-get install $1 -y 94 | else 95 | echo 96 | echo "Missing $1 - install it using your distro's package manager or build from source" 97 | _wait 98 | fi 99 | fi 100 | fi 101 | } 102 | 103 | CYGWIN_PACKAGES="make curl, libsasl2, ca-certificates, ncurses, python-setuptools" 104 | 105 | download() { 106 | url=$1 107 | filename=$2 108 | curl $url -L --O $filename 109 | } 110 | 111 | if [ `id -u` == 0 ]; then 112 | die "Error: running as root - don't use 'sudo' with this script" 113 | fi 114 | 115 | if ! command -v curl >/dev/null 2>&1; then 116 | if [ $OS == "cygwin" ]; then 117 | _cygwin_error "curl" 118 | else 119 | _install curl 120 | fi 121 | fi 122 | 123 | if [ $OS == "windows" ]; then 124 | die "Sorry, the bootstrap script for compiling from source doesn't support the Windows console - try Cygwin." 125 | fi 126 | 127 | if [ $OS == "mac" ] && ! command -v brew >/dev/null 2>&1; then 128 | echo "Installing Homebrew..." 129 | ruby -e "$(curl -fsSkL raw.github.com/mxcl/homebrew/go)" 130 | fi 131 | 132 | if ! command -v make >/dev/null 2>&1; then 133 | if [ $OS == "cygwin" ]; then 134 | _cygwin_error "make" 135 | elif [ $OS == "mac" ]; then 136 | die "Missing 'make' - install the Xcode CLI tools" 137 | else 138 | if [ $DISTRO == "arch" ]; then 139 | $SUDO_CMD pacman -S base-devel 140 | elif [ $DISTRO == "Ubuntu" ]; then 141 | $SUDO_CMD apt-get update -qq 142 | $SUDO_CMD apt-get install build-essential -y 143 | fi 144 | fi 145 | fi 146 | 147 | if ! command -v python >/dev/null 2>&1; then 148 | echo "Installing Python..." 149 | _install "python" 150 | fi 151 | 152 | if ! command -v pip >/dev/null 2>&1; then 153 | echo "Installing Pip..." 154 | if ! command -v easy_install >/dev/null 2>&1; then 155 | die "easy_install not available, can't install pip" 156 | fi 157 | 158 | $SUDO_CMD easy_install pip 159 | fi 160 | 161 | $SUDO_CMD pip install -U pip 162 | $SUDO_CMD pip install --pre -Ur pip-requirements.txt 163 | 164 | if ! command -v protoc >/dev/null 2>&1; then 165 | if [ $OS == "cygwin" ]; then 166 | _cygwin_error "protobuf" 167 | elif [ $OS == "mac" ] || [ $OS == "linux" ]; then 168 | if [ $DISTRO == "Ubuntu" ]; then 169 | _install protobuf-compiler 170 | else 171 | _install protobuf 172 | fi 173 | fi 174 | fi 175 | 176 | popd 177 | 178 | echo 179 | echo "${bldgreen}All developer dependencies installed, ready to compile.$txtrst" 180 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # OpenXC Message Format Specification 2 | 3 | Version: v0.8.0 4 | 5 | This specification is a part of the [OpenXC platform][OpenXC]. 6 | 7 | An OpenXC vehicle interface sends generic vehicle data over one or more output 8 | interfaces (e.g. USB or Bluetooth) as JSON or Protocol Buffers (protobuf). 9 | 10 | ## JSON 11 | 12 | The JSON format is the most flexible and easiest to use. The format is fully 13 | specified in the [JSON.mkd](JSON.mkd) file in this repository. 14 | a more flexible option than binary, but is less compact and 15 | therefore takes more bandwidth and processing power. 16 | 17 | The JSON format is best for most developers, as it is fairly efficient and very 18 | flexible. 19 | 20 | ## Binary (Protocol Buffers) 21 | 22 | The binary format is encoded using [Google Protocol 23 | Buffers](https://code.google.com/p/protobuf/). The format is specified in the 24 | file [openxc.proto](openxc.proto). The descriptions of the messages can be foud 25 | in the JSON specs - the binary format mirrors this. 26 | 27 | The binary messages are published by the VI using the standard length-delimited 28 | method (any protobuf library should support this). 29 | 30 | The binary format is best if you need to maximize the amount of data that can be 31 | sent from the VI, trading off flexibility for efficiency. 32 | 33 | ## Trace File Format 34 | 35 | An OpenXC vehicle trace file is a plaintext file that contains JSON objects, 36 | separated by newlines (which may be either `\r\n` or `\n`, depending on the 37 | platform the trace file was recorded). 38 | 39 | The first line may be a metadata object, although this is optional: 40 | 41 | ``` 42 | {"metadata": { 43 | "version": "v3.0", 44 | "vehicle_interface_id": "7ABF", 45 | "vehicle": { 46 | "make": "Ford", 47 | "model": "Mustang", 48 | "trim": "V6 Premium", 49 | "year": 2013 50 | }, 51 | "description": "highway drive to work", 52 | "driver_name": "TJ Giuli", 53 | "vehicle_id": "17N1039247929" 54 | } 55 | ``` 56 | 57 | The following lines are OpenXC messages with a `timestamp` field added, e.g.: 58 | 59 | {"timestamp": 1385133351.285525, "name": "steering_wheel_angle", "value": 45} 60 | 61 | The timestamp is in [UNIX time](http://en.wikipedia.org/wiki/Unix_time) 62 | (i.e. seconds since the UNIX epoch, 00:00:00 UTC, 1/1/1970). 63 | 64 | ## Official Signals 65 | 66 | These signal names are a part of the OpenXC specification, although some 67 | manufacturers may support custom message names. 68 | 69 | *Note: When compiling for platforms using Bluetooth LE, all signals below will have frequencies of 0.5 Hz due to bandwidth limitations.* 70 | 71 | * steering_wheel_angle 72 | * numerical, -600 to +600 degrees 73 | * 10Hz 74 | * torque_at_transmission 75 | * numerical, -500 to 1500 Nm 76 | * 10Hz 77 | * engine_speed 78 | * numerical, 0 to 16382 RPM 79 | * 10Hz 80 | * vehicle_speed 81 | * numerical, 0 to 655 km/h (this will be positive even if going in reverse 82 | as it's not a velocity, although you can use the gear status to figure out 83 | direction) 84 | * 10Hz 85 | * accelerator_pedal_position 86 | * percentage 87 | * 10Hz 88 | * parking_brake_status 89 | * boolean, (true == brake engaged) 90 | * 1Hz, but sent immediately on change 91 | * brake_pedal_status 92 | * boolean (True == pedal pressed) 93 | * 1Hz, but sent immediately on change 94 | * transmission_gear_position 95 | * states: first, second, third, fourth, fifth, sixth, seventh, eighth, 96 | ninth, tenth, reverse, neutral 97 | * 1Hz, but sent immediately on change 98 | * gear_lever_position 99 | * states: neutral, park, reverse, drive, sport, low, first, second, third, 100 | fourth, fifth, sixth, seventh, eighth, ninth, tenth 101 | * 1Hz, but sent immediately on change 102 | * odometer 103 | * Numerical, km 104 | 0 to 16777214.000 km, with about .2m resolution 105 | * 10Hz 106 | * ignition_status 107 | * states: off, accessory, run, start 108 | * 1Hz, but sent immediately on change 109 | * fuel_level 110 | * percentage 111 | * 2Hz 112 | * fuel_consumed_since_restart 113 | * numerical, 0 - 4294967295.0 L (this goes to 0 every time the vehicle 114 | restarts, like a trip meter) 115 | * 10Hz 116 | * door_status 117 | * Value is State: driver, passenger, rear_left, rear_right. 118 | * Event is boolean: true == ajar 119 | * 1Hz, but sent immediately on change 120 | * headlamp_status 121 | * boolean, true is on 122 | * 1Hz, but sent immediately on change 123 | * high_beam_status 124 | * boolean, true is on 125 | * 1Hz, but sent immediately on change 126 | * windshield_wiper_status 127 | * boolean, true is on 128 | * 1Hz, but sent immediately on change 129 | * latitude 130 | * numerical, -89.0 to 89.0 degrees with standard GPS accuracy 131 | * 1Hz 132 | * longitude 133 | * numerical, -179.0 to 179.0 degrees with standard GPS accuracy 134 | * 1Hz 135 | * button_event 136 | * Value is State: left, right, up, down, ok. 137 | * Event is State: idle, pressed, released, held_short, held_long, stuck 138 | * (The buttons this message refer to are highly dependent on the specific vehicle, but if it's supported, try the steering wheel buttons.) 139 | 140 | ## Signals from Diagnostic Messages 141 | 142 | This set of signals is often retreived from OBD-II requests. The units can be 143 | found in the [OBD-II standard](http://en.wikipedia.org/wiki/OBD-II_PIDs#Mode_01). 144 | 145 | * engine_load 146 | * engine_coolant_temperature 147 | * barometric_pressure 148 | * commanded_throttle_position 149 | * throttle_position 150 | * fuel_level 151 | * intake_air_temperature 152 | * intake_manifold_pressure 153 | * running_time 154 | * fuel_pressure 155 | * mass_airflow 156 | * accelerator_pedal_position 157 | * ethanol_fuel_percentage 158 | * engine_oil_temperature 159 | * engine_torque 160 | 161 | License 162 | ======= 163 | 164 | Copyright (c) 2012-2021 Ford Motor Company 165 | 166 | Licensed under the BSD license. 167 | 168 | [OpenXC]: http://openxcplatform.com 169 | -------------------------------------------------------------------------------- /JSON.mkd: -------------------------------------------------------------------------------- 1 | # OpenXC JSON Message Format 2 | 3 | Each JSON message published by a VI is delimited with a `\0 ` character. 4 | 5 | ## Table of Contents 6 | 1. [Vehicle Messages](#vehicle-messages) 7 | 2. [CAN Message](#can-message) 8 | 3. [Diagnostic Message](#diagnostic-message) 9 | 4. [Commands](#commands) 10 | 5. [Extra Values](#extra-values) 11 | 12 | ## Vehicle Messages 13 | 14 | ### Simple Vehicle Message 15 | 16 | There may not be a 1:1 relationship between input and output signals - i.e. 17 | engine timing CAN signals may be summarized in an "engine performance" metric on 18 | the abstract side of the interface. 19 | 20 | The expected format of a single valued message is: 21 | 22 | {"name": "steering_wheel_angle", "value": 45} 23 | 24 | ### Evented Simple Vehicle Message 25 | 26 | The expected format of an event message is: 27 | 28 | {"name": "button_event", "value": "up", "event": "pressed"} 29 | 30 | This format is good for something like a button event, where there are two 31 | discrete pieces of information in the measurement. 32 | 33 | ## CAN Message 34 | 35 | The format for a plain CAN message: 36 | 37 | {"bus": 1, "id": 1234, "data": "0x12345678"} 38 | 39 | **bus** - the numerical identifier of the CAN bus where this message originated, 40 | most likely 1 or 2 (for a vehicle interface with 2 CAN controllers). 41 | 42 | **id** - the CAN message ID 43 | 44 | **data** - up to 8 bytes of data from the CAN message's payload, represented as 45 | a hexidecimal number in a string. Many JSON parser cannot handle 64-bit 46 | integers, which is why we are not using a numerical data type. Each byte in 47 | the string *must* be represented with 2 characters, e.g. `0x1` is `0x01` - the 48 | complete string must have an even number of characters. The `0x` prefix is 49 | optional. 50 | 51 | **format** - (optional) explicitly set the frame format for the CAN message, one 52 | of `standard` or `extended`. If the `id` is greater than `0x7ff`, the extended 53 | frame format will be selected automatically. 54 | 55 | ## Diagnostic Message 56 | 57 | ### Requests 58 | 59 | A diagnostic request is added or cancelled with a JSON object like this example: 60 | 61 | { "command": "diagnostic_request", 62 | "action": "add", 63 | "diagnostic_request": { 64 | "bus": 1, 65 | "message_id": 1234, 66 | "mode": 1, 67 | "pid": 5, 68 | "payload": "0x1234", 69 | "multiple_responses": false, 70 | "frequency": 1, 71 | "name": "my_pid" 72 | } 73 | } 74 | } 75 | 76 | * The `command` must be `diagnostic_request.` 77 | * The `action` must be included, and must be one of: 78 | * `add` - create a new one-off or recurring diagnostic request. 79 | * `cancel` - cancel an existing request. 80 | * The details of the request must be included in the `request` field, using 81 | the sub-fields defined below. 82 | 83 | A diagnostic request's `bus`, `id`, `mode` and `pid` (or lack of a `pid`) 84 | combine to create a unique key to identify a request. These four fields will be 85 | referred to as the key of the diagnostic request. For example, to create a 86 | simple one-time diagnostic request: 87 | 88 | { "command": "diagnostic_request", 89 | "action": "add", 90 | "diagnostic_request": { 91 | "bus": 1, 92 | "message_id": 1234, 93 | "mode": 1, 94 | "pid": 5 95 | } 96 | } 97 | } 98 | 99 | Requests are completed after any responses are received (unless 100 | `multiple_responses` is set), or the request has timed out after a certain 101 | number of seconds. After a request is completed, you can re-`create` the same 102 | key to make another request. 103 | 104 | Requests with a `frequency` are added as *recurring* requests, e.g. to add the 105 | previous example as a recurring request at 1Hz: 106 | 107 | { "command": "diagnostic_request", 108 | "action": "add", 109 | "diagnostic_request": { 110 | "bus": 1, 111 | "message_id": 1234, 112 | "mode": 1, 113 | "pid": 5, 114 | "frequency": 1 115 | } 116 | } 117 | } 118 | 119 | To cancel a recurring request, send a `cancel` action with the same key, e.g.: 120 | 121 | { "command": "diagnostic_request", 122 | "action": "cancel", 123 | "diagnostic_request": { 124 | "bus": 1, 125 | "message_id": 1234, 126 | "mode": 1, 127 | "pid": 5 128 | } 129 | } 130 | } 131 | 132 | Simultaneous recurring requests for the same key at different rates (e.g. 1Hz 133 | *and* 2Hz) is not supported. However, non-recurring ("one-off") requests may 134 | exist in parallel with a recurring request for the same key. 135 | 136 | **bus** - the numerical identifier of the CAN bus where this request should be 137 | sent, most likely 1 or 2 (for a vehicle interface with 2 CAN controllers). 138 | 139 | **message_id** - the CAN message ID for the request. 140 | 141 | **mode** - the OBD-II mode of the request - 0x1 through 0xff (1 through 9 are the 142 | standardized modes and 0x22 is a common proprietary mode). 143 | 144 | **pid** - (optional) the PID for the request, if applicable. 145 | 146 | **payload** - (optional) up to 7 bytes of data for the request's payload 147 | represented as a hexadecimal number in a string. Many JSON parser cannot 148 | handle 64-bit integers, which is why we are not using a numerical data type. 149 | Each byte in the string *must* be represented with 2 characters, e.g. `0x1` 150 | is `0x01` - the complete string must have an even number of characters. The 151 | `0x` prefix is optional. 152 | 153 | **name** - (optional, defaults to nothing) A human readable, string name for 154 | this request. If provided, the response will have a `name` field (much like a 155 | simple vehicle message) with this value in place of `bus`, `id`, `mode` and 156 | `pid`. 157 | 158 | **multiple_responses** - (optional, false by default) if true, request will stay 159 | active for a full 100ms, even after receiving a diagnostic response message. 160 | This is useful for requests to the functional broadcast message ID 161 | (`0x7df`) when you need to get responses from multiple modules. It's possible 162 | to set this to `true` for non-broadcast requests, but in practice you won't 163 | see any additional responses after the first and it will just take up memory 164 | in the VI for longer. 165 | 166 | **frequency** - (optional) Make this request a recurring request, at a this 167 | frequency in Hz. To send a single non-recurring request, leave this field out. 168 | 169 | **decoded_type** - (optional, defaults to "obd2" if the request is a recognized 170 | OBD-II mode 1 request, otherwise "none") If specified, the valid values are 171 | `"none"` and `"obd2"`. If `obd2`, the payload will be decoded according to the 172 | OBD-II specification and returned in the `value` field. Set this to `none` to 173 | manually override the OBD-II decoding feature for a known PID. 174 | 175 | ### Responses 176 | 177 | Requests to add or cancel a diagnostic request are first acknowledged by the VI, 178 | before any responses to the request are returned. The response uses the standard 179 | command response format: 180 | 181 | { "command_response": "diagnostic_request", "status": true} 182 | 183 | **status** - true if the request was successfully created or cancelled. 184 | 185 | When a node on the network response to the request and the result is published 186 | by the VI, the result looks like: 187 | 188 | {"bus": 1, 189 | "message_id": 1234, 190 | "mode": 1, 191 | "pid": 5, 192 | "success": true, 193 | "payload": "0x1234", 194 | "value": 4660} 195 | 196 | and to an unsuccessful request, with the `negative_response_code` and no `pid` 197 | echo: 198 | 199 | {"bus": 1, 200 | "message_id": 1234, 201 | "mode": 1, 202 | "success": false, 203 | "negative_response_code": 17} 204 | 205 | **bus** - the numerical identifier of the CAN bus where this response was 206 | received. 207 | 208 | **message_id** - the CAN message ID for this response. 209 | 210 | **mode** - the OBD-II mode of the original diagnostic request. 211 | 212 | **pid** - (optional) the PID for the request, if applicable. 213 | 214 | **success** - true if the response received was a positive response. If this 215 | field is false, the remote node returned an error and the 216 | `negative_response_code` field should be populated. 217 | 218 | **negative_response_code** - (optional) If requested node returned an error, 219 | `success` will be `false` and this field will contain the negative response 220 | code (NRC). 221 | 222 | Finally, the `payload` and `value` fields are mutually exclusive: 223 | 224 | **payload** - (optional) up to 7 bytes of data returned in the response, 225 | represented as a hexadecimal number in a string. Many JSON parser cannot 226 | handle 64-bit integers, which is why we are not using a numerical data type. 227 | 228 | **value** - (optional) if the response had a payload, this may be the 229 | payload interpreted as an integer. 230 | 231 | The response to a simple PID request would look like this: 232 | 233 | {"success": true, "bus": 1, "message_id": 1234, "mode": 1, "pid": 5, "payload": "0x2"} 234 | 235 | ### Multi-frame Responses 236 | 237 | For larger Diagnostic Response payloads, the response will be returned in multiple 238 | messages. In such a case, there will be two addition fields in the response, 239 | a "frame" and a "total_size" field. 240 | 241 | {"bus": 1, 242 | "frame": 0, 243 | "message_id": 1234, 244 | "mode": 1, 245 | "pid": 5, 246 | "success": true, 247 | "payload": "0x1234", 248 | "total_size": 24, 249 | "value": 4660} 250 | 251 | **frame** - A zero based index indicating which sequnential block for the 252 | payload segment, A "-1" will denote that this is the last frame. 253 | 254 | **total_size** - The total size in bytes of all payload segments in this 255 | chain of response segments. 256 | 257 | **payload** - The payload will be returned as Hexidecimal value representing the 258 | binary bytes of the payload. Each payload will be preficed with a "0x" 259 | 260 | Here is an example 2 part response for a diagnostic request of message:0x7d0, 261 | mode:0x22, and pid:0xde00: 262 | 263 | {"frame":0, 264 | "id":2000, 265 | "bus":1, 266 | "mode":34, 267 | "total_size":10, 268 | "pid":34, 269 | "value":0, 270 | "payload":"0x62DE00222a04"} 271 | 272 | {"frame":-1, 273 | "id":2000, 274 | "bus":1, 275 | "mode":34, 276 | "total_size":10, 277 | "pid":34, 278 | "value":0, 279 | "payload":"0x03000AC800008A"} 280 | 281 | Note: There are 3 leading bytes of meta data at the start of the payload that 282 | contain the pid, the mode and a bit field containing the size of the response. 283 | 284 | ## Commands 285 | 286 | In addition to the `diagnostic_request` command described earlier, there are 287 | other possible values for the `command` field. 288 | 289 | All commands immediately return a `command_response`, e.g.: 290 | 291 | { "command_response": "version", "message": "v6.0-dev (default)", "status": true} 292 | 293 | **command_response** - an echo of the command this is a ACKing. 294 | 295 | **status** - true if the command was understood and performed succesfully. 296 | 297 | **message** - (optional) a string message from the VI, e.g. to return a version 298 | descriptor or error message. 299 | 300 | ### Version Query 301 | 302 | The `version` command triggers the VI to inject a firmware version identifier 303 | response into the outgoing data stream. 304 | 305 | **Request** 306 | 307 | { "command": "version"} 308 | 309 | **Response** 310 | 311 | { "command_response": "version", "message": "v6.0-dev (default)", "status": true} 312 | 313 | ### Device ID Query 314 | 315 | The `device_id` command triggers the VI to inject a unique device ID (e.g. the 316 | MAC address of an included Bluetooth module) into into the outgoing data stream. 317 | 318 | If no device ID is available, the response message will be "Unknown". 319 | 320 | **Request** 321 | 322 | { "command": "device_id"} 323 | 324 | **Response** 325 | 326 | { "command_response": "device_id", "message": "0012345678", "status": true} 327 | 328 | ### Platform Query 329 | 330 | The `platform` command triggers the VI to inject a platform identifier into into the outgoing data stream. 331 | 332 | **Request** 333 | 334 | { "command": "platform"} 335 | 336 | **Response** 337 | 338 | { "command_response": "platform", "message": "FORDBOARD", "status": true} 339 | 340 | ### Passthrough CAN Mode 341 | 342 | The `passthrough` command controls whether low-level CAN messages are passed 343 | through from the CAN bus through the VI to the output stream. If the CAN 344 | acceptance filter is in bypass mode and passthrough is enabled, the output 345 | stream will include all received CAN messages. If the bypass filter is enabled, 346 | only those CAN messages that have been pre-defined in the firmware are 347 | forwarded. 348 | 349 | **Request** 350 | 351 | { "command": "passthrough", 352 | "bus": 1, 353 | "enabled": true 354 | } 355 | 356 | **Response** 357 | 358 | If the bus in the request was valid and the passthrough mode was changed, the 359 | `status` field in the response will be `true`. If `false`, the passthrough mode 360 | was not changed. 361 | 362 | { "command_response": "passthrough", "status": true} 363 | 364 | ### Acceptance Filter Bypass 365 | 366 | The `af_bypass` command controls whether the CAN message acceptance filter is 367 | bypassed for each CAN controller. By default, hardware acceptance filter (AF) is 368 | enabled in the VI - only previously defined CAN message IDs will be received. 369 | Send this command with `bypass: true` to force the filters to bypassed. 370 | 371 | If `passthrough` mode is also enabled, when the AF is bypassed, the output will 372 | include all CAN messages received. 373 | 374 | **Request** 375 | 376 | { "command": "af_bypass", 377 | "bus": 1, 378 | "bypass": true 379 | } 380 | 381 | **Response** 382 | 383 | If the bus in the request was valid and the AF mode was changed, the `status` 384 | field in the response will be `true`. If `false`, the passthrough mode was not 385 | changed. 386 | 387 | { "command_response": "af_bypass", "status": true} 388 | 389 | ### Payload Format Control 390 | 391 | The `payload_format` command determines the format for output data from the VI 392 | and the expected format of commands sent to the VI. 393 | 394 | Valid formats are `json` and `protobuf`. 395 | 396 | **Request** 397 | 398 | { "command": "payload_format", 399 | "format": "json" 400 | } 401 | 402 | **Response** 403 | 404 | If the format was changed successfully, the `status` in the response will be 405 | `true`. The response will be in the original message format, and all subsequent 406 | messages will be in the new format. 407 | 408 | { "command_response": "payload_format", "status": true} 409 | 410 | ### Automatic Pre-Defined OBD-II PID Requests 411 | 412 | The `predefined_obd2` command enables and disables the querying for and 413 | translating of a set of pre-defined OBD-II PIDs from the attached vehicle. When 414 | enabled, the VI will query the vehicle to see if these PIDs are claimed to be 415 | supported and for those that are, it will set up recurring requests. The 416 | responses will be output as simple vehicle messages, with the names defined in 417 | the "Signals Defined from Diagnostic Messages" section below. 418 | 419 | **Request** 420 | 421 | { "command": "predefined_obd2", 422 | "enabled": true 423 | } 424 | 425 | **Response** 426 | 427 | If the predefined requests were enabled or disabled successfully, the `status` in 428 | the response will be `true`. 429 | 430 | { "command_response": "predefined_obd2", "status": true} 431 | 432 | ### C5 Cellular Configuration 433 | 434 | The ModemConfigurationCommand message allows users to change certain aspects of modem operation on-the-fly (at runtime). The modem configuration settings are stored in flash memory and are untouched by the bootloader during a software update (assuming the correct cellular_c5 linker file is used during compilation of vi-firmware). Thus, new modem settings persistent across power cycles. 435 | 436 | The ModemConfigurationCommand message provides three sub-messages for particular groups of modem settings. These are NetworkOperatorSettings, NetworkDataSettings, and ServerConnectSettings. These configuration messages are described in great detail within the [c5_cellular_config](https://github.com/openxc/vi-firmware/docs/advanced/c5_cell_config.html) documentation. 437 | 438 | Currently, only the ServerConnectSettings sub-message is supported in the vi-firmware's command interpreter. All other settings are currently compile-time only. 439 | 440 | The ServerConnectSettings part of ModemConfigurationCommand allows the user to set the host server name and port that the device will use when opening a TCP socket to upload data. This destination must be running an HTTP server similar to [OpenXCWebServer](https://github.com/openxc/openxc-azure-webserver), which defines a set of supported HTTP transactions where the body is comprised of data in the familiar OpenXC Message Format. 441 | 442 | **Request** 443 | 444 | { "command": "modem_configuration", 445 | "server": { 446 | "host": "www.myhost.com", 447 | "port": 10000 448 | } 449 | } 450 | 451 | **Response** 452 | 453 | { "command_response": "modem_configuration", "status": true} 454 | 455 | ## C5 SD Card Status 456 | 457 | In order to check the status of the SD card, the following command is available: 458 | 459 | { "command": "sd_mount_status"} 460 | 461 | Command response if the SD card is mounted correctly: 462 | 463 | { "command_response": "sd_mount_status", "status": true} 464 | 465 | If the SD card is full, not enabled, or connected as a MSD, the device will respond with: 466 | 467 | { "command_response": "sd_mount_status", "status": false} 468 | 469 | For more info see [c5_msd](https://github.com/openxc/vi-firmware/docs/advanced/msd.html). 470 | 471 | ## C5 RTC Configuration 472 | 473 | To set the current time of the RTC, the following 474 | 475 | { "command": "rtc_configuration", "unix_time": "1448551563"} 476 | 477 | The response is 478 | 479 | { "command_response": "rtc_configuration", "status": true} 480 | 481 | For more info see [c5_rtc](https://github.com/openxc/vi-firmware/docs/advanced/rtc.html). 482 | 483 | ## Extra Values 484 | 485 | Any of the following JSON objects may optionally include an `extras` 486 | field. The value may be any valid JSON object or array. The client libraries 487 | will do their best to parse this information into a generic format and pass it 488 | to your application. For example: 489 | 490 | {"name": "steering_wheel_angle", 491 | "value": 45, 492 | "extras": { 493 | "calibrated": false 494 | } 495 | } 496 | 497 | -------------------------------------------------------------------------------- /gen/cpp/openxc.pb.h: -------------------------------------------------------------------------------- 1 | /* Automatically generated nanopb header */ 2 | /* Generated by nanopb-0.4.0-dev */ 3 | 4 | #ifndef PB_OPENXC_OPENXC_PB_H_INCLUDED 5 | #define PB_OPENXC_OPENXC_PB_H_INCLUDED 6 | #include 7 | 8 | /* @@protoc_insertion_point(includes) */ 9 | #if PB_PROTO_HEADER_VERSION != 40 10 | #error Regenerate this file with the current version of nanopb generator. 11 | #endif 12 | 13 | #ifdef __cplusplus 14 | extern "C" { 15 | #endif 16 | 17 | /* Enum definitions */ 18 | typedef enum _openxc_VehicleMessage_Type { 19 | openxc_VehicleMessage_Type_UNUSED = 0, 20 | openxc_VehicleMessage_Type_CAN = 1, 21 | openxc_VehicleMessage_Type_SIMPLE = 2, 22 | openxc_VehicleMessage_Type_DIAGNOSTIC = 3, 23 | openxc_VehicleMessage_Type_CONTROL_COMMAND = 4, 24 | openxc_VehicleMessage_Type_COMMAND_RESPONSE = 5 25 | } openxc_VehicleMessage_Type; 26 | #define _openxc_VehicleMessage_Type_MIN openxc_VehicleMessage_Type_UNUSED 27 | #define _openxc_VehicleMessage_Type_MAX openxc_VehicleMessage_Type_COMMAND_RESPONSE 28 | #define _openxc_VehicleMessage_Type_ARRAYSIZE ((openxc_VehicleMessage_Type)(openxc_VehicleMessage_Type_COMMAND_RESPONSE+1)) 29 | 30 | typedef enum _openxc_CanMessage_FrameFormat { 31 | openxc_CanMessage_FrameFormat_UNUSED = 0, 32 | openxc_CanMessage_FrameFormat_STANDARD = 1, 33 | openxc_CanMessage_FrameFormat_EXTENDED = 2 34 | } openxc_CanMessage_FrameFormat; 35 | #define _openxc_CanMessage_FrameFormat_MIN openxc_CanMessage_FrameFormat_UNUSED 36 | #define _openxc_CanMessage_FrameFormat_MAX openxc_CanMessage_FrameFormat_EXTENDED 37 | #define _openxc_CanMessage_FrameFormat_ARRAYSIZE ((openxc_CanMessage_FrameFormat)(openxc_CanMessage_FrameFormat_EXTENDED+1)) 38 | 39 | typedef enum _openxc_ControlCommand_Type { 40 | openxc_ControlCommand_Type_UNUSED = 0, 41 | openxc_ControlCommand_Type_VERSION = 1, 42 | openxc_ControlCommand_Type_DEVICE_ID = 2, 43 | openxc_ControlCommand_Type_DIAGNOSTIC = 3, 44 | openxc_ControlCommand_Type_PASSTHROUGH = 4, 45 | openxc_ControlCommand_Type_ACCEPTANCE_FILTER_BYPASS = 5, 46 | openxc_ControlCommand_Type_PAYLOAD_FORMAT = 6, 47 | openxc_ControlCommand_Type_PREDEFINED_OBD2_REQUESTS = 7, 48 | openxc_ControlCommand_Type_MODEM_CONFIGURATION = 8, 49 | openxc_ControlCommand_Type_RTC_CONFIGURATION = 9, 50 | openxc_ControlCommand_Type_SD_MOUNT_STATUS = 10, 51 | openxc_ControlCommand_Type_PLATFORM = 11, 52 | openxc_ControlCommand_Type_GET_VIN = 12 53 | } openxc_ControlCommand_Type; 54 | #define _openxc_ControlCommand_Type_MIN openxc_ControlCommand_Type_UNUSED 55 | #define _openxc_ControlCommand_Type_MAX openxc_ControlCommand_Type_GET_VIN 56 | #define _openxc_ControlCommand_Type_ARRAYSIZE ((openxc_ControlCommand_Type)(openxc_ControlCommand_Type_GET_VIN+1)) 57 | 58 | typedef enum _openxc_DiagnosticControlCommand_Action { 59 | openxc_DiagnosticControlCommand_Action_UNUSED = 0, 60 | openxc_DiagnosticControlCommand_Action_ADD = 1, 61 | openxc_DiagnosticControlCommand_Action_CANCEL = 2 62 | } openxc_DiagnosticControlCommand_Action; 63 | #define _openxc_DiagnosticControlCommand_Action_MIN openxc_DiagnosticControlCommand_Action_UNUSED 64 | #define _openxc_DiagnosticControlCommand_Action_MAX openxc_DiagnosticControlCommand_Action_CANCEL 65 | #define _openxc_DiagnosticControlCommand_Action_ARRAYSIZE ((openxc_DiagnosticControlCommand_Action)(openxc_DiagnosticControlCommand_Action_CANCEL+1)) 66 | 67 | typedef enum _openxc_PayloadFormatCommand_PayloadFormat { 68 | openxc_PayloadFormatCommand_PayloadFormat_UNUSED = 0, 69 | openxc_PayloadFormatCommand_PayloadFormat_JSON = 1, 70 | openxc_PayloadFormatCommand_PayloadFormat_PROTOBUF = 2 71 | } openxc_PayloadFormatCommand_PayloadFormat; 72 | #define _openxc_PayloadFormatCommand_PayloadFormat_MIN openxc_PayloadFormatCommand_PayloadFormat_UNUSED 73 | #define _openxc_PayloadFormatCommand_PayloadFormat_MAX openxc_PayloadFormatCommand_PayloadFormat_PROTOBUF 74 | #define _openxc_PayloadFormatCommand_PayloadFormat_ARRAYSIZE ((openxc_PayloadFormatCommand_PayloadFormat)(openxc_PayloadFormatCommand_PayloadFormat_PROTOBUF+1)) 75 | 76 | typedef enum _openxc_NetworkOperatorSettings_OperatorSelectMode { 77 | openxc_NetworkOperatorSettings_OperatorSelectMode_AUTOMATIC = 0, 78 | openxc_NetworkOperatorSettings_OperatorSelectMode_MANUAL = 1, 79 | openxc_NetworkOperatorSettings_OperatorSelectMode_DEREGISTER = 2, 80 | openxc_NetworkOperatorSettings_OperatorSelectMode_SET_ONLY = 3, 81 | openxc_NetworkOperatorSettings_OperatorSelectMode_MANUAL_AUTOMATIC = 4 82 | } openxc_NetworkOperatorSettings_OperatorSelectMode; 83 | #define _openxc_NetworkOperatorSettings_OperatorSelectMode_MIN openxc_NetworkOperatorSettings_OperatorSelectMode_AUTOMATIC 84 | #define _openxc_NetworkOperatorSettings_OperatorSelectMode_MAX openxc_NetworkOperatorSettings_OperatorSelectMode_MANUAL_AUTOMATIC 85 | #define _openxc_NetworkOperatorSettings_OperatorSelectMode_ARRAYSIZE ((openxc_NetworkOperatorSettings_OperatorSelectMode)(openxc_NetworkOperatorSettings_OperatorSelectMode_MANUAL_AUTOMATIC+1)) 86 | 87 | typedef enum _openxc_NetworkOperatorSettings_NetworkDescriptor_NetworkType { 88 | openxc_NetworkOperatorSettings_NetworkDescriptor_NetworkType_GSM = 0, 89 | openxc_NetworkOperatorSettings_NetworkDescriptor_NetworkType_UTRAN = 2 90 | } openxc_NetworkOperatorSettings_NetworkDescriptor_NetworkType; 91 | #define _openxc_NetworkOperatorSettings_NetworkDescriptor_NetworkType_MIN openxc_NetworkOperatorSettings_NetworkDescriptor_NetworkType_GSM 92 | #define _openxc_NetworkOperatorSettings_NetworkDescriptor_NetworkType_MAX openxc_NetworkOperatorSettings_NetworkDescriptor_NetworkType_UTRAN 93 | #define _openxc_NetworkOperatorSettings_NetworkDescriptor_NetworkType_ARRAYSIZE ((openxc_NetworkOperatorSettings_NetworkDescriptor_NetworkType)(openxc_NetworkOperatorSettings_NetworkDescriptor_NetworkType_UTRAN+1)) 94 | 95 | typedef enum _openxc_DiagnosticRequest_DecodedType { 96 | openxc_DiagnosticRequest_DecodedType_UNUSED = 0, 97 | openxc_DiagnosticRequest_DecodedType_NONE = 1, 98 | openxc_DiagnosticRequest_DecodedType_OBD2 = 2 99 | } openxc_DiagnosticRequest_DecodedType; 100 | #define _openxc_DiagnosticRequest_DecodedType_MIN openxc_DiagnosticRequest_DecodedType_UNUSED 101 | #define _openxc_DiagnosticRequest_DecodedType_MAX openxc_DiagnosticRequest_DecodedType_OBD2 102 | #define _openxc_DiagnosticRequest_DecodedType_ARRAYSIZE ((openxc_DiagnosticRequest_DecodedType)(openxc_DiagnosticRequest_DecodedType_OBD2+1)) 103 | 104 | typedef enum _openxc_DynamicField_Type { 105 | openxc_DynamicField_Type_UNUSED = 0, 106 | openxc_DynamicField_Type_STRING = 1, 107 | openxc_DynamicField_Type_NUM = 2, 108 | openxc_DynamicField_Type_BOOL = 3 109 | } openxc_DynamicField_Type; 110 | #define _openxc_DynamicField_Type_MIN openxc_DynamicField_Type_UNUSED 111 | #define _openxc_DynamicField_Type_MAX openxc_DynamicField_Type_BOOL 112 | #define _openxc_DynamicField_Type_ARRAYSIZE ((openxc_DynamicField_Type)(openxc_DynamicField_Type_BOOL+1)) 113 | 114 | /* Struct definitions */ 115 | typedef struct _openxc_AcceptanceFilterBypassCommand { 116 | int32_t bus; 117 | bool bypass; 118 | /* @@protoc_insertion_point(struct:openxc_AcceptanceFilterBypassCommand) */ 119 | } openxc_AcceptanceFilterBypassCommand; 120 | 121 | 122 | typedef PB_BYTES_ARRAY_T(8) openxc_CanMessage_data_t; 123 | typedef struct _openxc_CanMessage { 124 | int32_t bus; 125 | uint32_t id; 126 | openxc_CanMessage_data_t data; 127 | openxc_CanMessage_FrameFormat frame_format; 128 | /* @@protoc_insertion_point(struct:openxc_CanMessage) */ 129 | } openxc_CanMessage; 130 | 131 | 132 | typedef struct _openxc_CommandResponse { 133 | openxc_ControlCommand_Type type; 134 | char message[128]; 135 | bool status; 136 | /* @@protoc_insertion_point(struct:openxc_CommandResponse) */ 137 | } openxc_CommandResponse; 138 | 139 | 140 | typedef PB_BYTES_ARRAY_T(8) openxc_DiagnosticRequest_payload_t; 141 | typedef struct _openxc_DiagnosticRequest { 142 | int32_t bus; 143 | uint32_t message_id; 144 | uint32_t mode; 145 | uint32_t pid; 146 | openxc_DiagnosticRequest_payload_t payload; 147 | bool multiple_responses; 148 | double frequency; 149 | char name[10]; 150 | openxc_DiagnosticRequest_DecodedType decoded_type; 151 | /* @@protoc_insertion_point(struct:openxc_DiagnosticRequest) */ 152 | } openxc_DiagnosticRequest; 153 | 154 | 155 | typedef struct _openxc_DynamicField { 156 | openxc_DynamicField_Type type; 157 | char string_value[128]; 158 | double numeric_value; 159 | bool boolean_value; 160 | /* @@protoc_insertion_point(struct:openxc_DynamicField) */ 161 | } openxc_DynamicField; 162 | 163 | 164 | typedef struct _openxc_NetworkDataSettings { 165 | char apn[64]; 166 | /* @@protoc_insertion_point(struct:openxc_NetworkDataSettings) */ 167 | } openxc_NetworkDataSettings; 168 | 169 | 170 | typedef struct _openxc_NetworkOperatorSettings_NetworkDescriptor { 171 | uint32_t PLMN; 172 | openxc_NetworkOperatorSettings_NetworkDescriptor_NetworkType networkType; 173 | /* @@protoc_insertion_point(struct:openxc_NetworkOperatorSettings_NetworkDescriptor) */ 174 | } openxc_NetworkOperatorSettings_NetworkDescriptor; 175 | 176 | 177 | typedef struct _openxc_PassthroughModeControlCommand { 178 | int32_t bus; 179 | bool enabled; 180 | /* @@protoc_insertion_point(struct:openxc_PassthroughModeControlCommand) */ 181 | } openxc_PassthroughModeControlCommand; 182 | 183 | 184 | typedef struct _openxc_PayloadFormatCommand { 185 | openxc_PayloadFormatCommand_PayloadFormat format; 186 | /* @@protoc_insertion_point(struct:openxc_PayloadFormatCommand) */ 187 | } openxc_PayloadFormatCommand; 188 | 189 | 190 | typedef struct _openxc_PredefinedObd2RequestsCommand { 191 | bool enabled; 192 | /* @@protoc_insertion_point(struct:openxc_PredefinedObd2RequestsCommand) */ 193 | } openxc_PredefinedObd2RequestsCommand; 194 | 195 | 196 | typedef struct _openxc_RTCConfigurationCommand { 197 | uint32_t unix_time; 198 | /* @@protoc_insertion_point(struct:openxc_RTCConfigurationCommand) */ 199 | } openxc_RTCConfigurationCommand; 200 | 201 | 202 | typedef struct _openxc_ServerConnectSettings { 203 | char host[128]; 204 | uint32_t port; 205 | /* @@protoc_insertion_point(struct:openxc_ServerConnectSettings) */ 206 | } openxc_ServerConnectSettings; 207 | 208 | 209 | typedef struct _openxc_DiagnosticControlCommand { 210 | openxc_DiagnosticRequest request; 211 | openxc_DiagnosticControlCommand_Action action; 212 | /* @@protoc_insertion_point(struct:openxc_DiagnosticControlCommand) */ 213 | } openxc_DiagnosticControlCommand; 214 | 215 | 216 | typedef PB_BYTES_ARRAY_T(255) openxc_DiagnosticResponse_payload_t; 217 | typedef struct _openxc_DiagnosticResponse { 218 | int32_t bus; 219 | uint32_t message_id; 220 | uint32_t mode; 221 | uint32_t pid; 222 | bool success; 223 | uint32_t negative_response_code; 224 | openxc_DiagnosticResponse_payload_t payload; 225 | openxc_DynamicField value; 226 | int32_t frame; 227 | uint32_t total_size; 228 | /* @@protoc_insertion_point(struct:openxc_DiagnosticResponse) */ 229 | } openxc_DiagnosticResponse; 230 | 231 | 232 | typedef struct _openxc_NetworkOperatorSettings { 233 | bool allowDataRoaming; 234 | openxc_NetworkOperatorSettings_OperatorSelectMode operatorSelectMode; 235 | openxc_NetworkOperatorSettings_NetworkDescriptor networkDescriptor; 236 | /* @@protoc_insertion_point(struct:openxc_NetworkOperatorSettings) */ 237 | } openxc_NetworkOperatorSettings; 238 | 239 | 240 | typedef struct _openxc_SimpleMessage { 241 | char name[100]; 242 | openxc_DynamicField value; 243 | openxc_DynamicField event; 244 | /* @@protoc_insertion_point(struct:openxc_SimpleMessage) */ 245 | } openxc_SimpleMessage; 246 | 247 | 248 | typedef struct _openxc_ModemConfigurationCommand { 249 | openxc_NetworkOperatorSettings networkOperatorSettings; 250 | openxc_NetworkDataSettings networkDataSettings; 251 | openxc_ServerConnectSettings serverConnectSettings; 252 | /* @@protoc_insertion_point(struct:openxc_ModemConfigurationCommand) */ 253 | } openxc_ModemConfigurationCommand; 254 | 255 | 256 | typedef struct _openxc_ControlCommand { 257 | openxc_ControlCommand_Type type; 258 | openxc_DiagnosticControlCommand diagnostic_request; 259 | openxc_PassthroughModeControlCommand passthrough_mode_request; 260 | openxc_AcceptanceFilterBypassCommand acceptance_filter_bypass_command; 261 | openxc_PayloadFormatCommand payload_format_command; 262 | openxc_PredefinedObd2RequestsCommand predefined_obd2_requests_command; 263 | openxc_ModemConfigurationCommand modem_configuration_command; 264 | openxc_RTCConfigurationCommand rtc_configuration_command; 265 | /* @@protoc_insertion_point(struct:openxc_ControlCommand) */ 266 | } openxc_ControlCommand; 267 | 268 | 269 | typedef struct _openxc_VehicleMessage { 270 | openxc_VehicleMessage_Type type; 271 | openxc_CanMessage can_message; 272 | openxc_SimpleMessage simple_message; 273 | openxc_DiagnosticResponse diagnostic_response; 274 | openxc_ControlCommand control_command; 275 | openxc_CommandResponse command_response; 276 | uint64_t timestamp; 277 | /* @@protoc_insertion_point(struct:openxc_VehicleMessage) */ 278 | } openxc_VehicleMessage; 279 | 280 | 281 | /* Initializer values for message structs */ 282 | #define openxc_VehicleMessage_init_default {_openxc_VehicleMessage_Type_MIN, openxc_CanMessage_init_default, openxc_SimpleMessage_init_default, openxc_DiagnosticResponse_init_default, openxc_ControlCommand_init_default, openxc_CommandResponse_init_default, 0} 283 | #define openxc_CanMessage_init_default {0, 0, {0, {0}}, _openxc_CanMessage_FrameFormat_MIN} 284 | #define openxc_ControlCommand_init_default {_openxc_ControlCommand_Type_MIN, openxc_DiagnosticControlCommand_init_default, openxc_PassthroughModeControlCommand_init_default, openxc_AcceptanceFilterBypassCommand_init_default, openxc_PayloadFormatCommand_init_default, openxc_PredefinedObd2RequestsCommand_init_default, openxc_ModemConfigurationCommand_init_default, openxc_RTCConfigurationCommand_init_default} 285 | #define openxc_DiagnosticControlCommand_init_default {openxc_DiagnosticRequest_init_default, _openxc_DiagnosticControlCommand_Action_MIN} 286 | #define openxc_PassthroughModeControlCommand_init_default {0, 0} 287 | #define openxc_AcceptanceFilterBypassCommand_init_default {0, 0} 288 | #define openxc_PayloadFormatCommand_init_default {_openxc_PayloadFormatCommand_PayloadFormat_MIN} 289 | #define openxc_PredefinedObd2RequestsCommand_init_default {0} 290 | #define openxc_NetworkOperatorSettings_init_default {0, _openxc_NetworkOperatorSettings_OperatorSelectMode_MIN, openxc_NetworkOperatorSettings_NetworkDescriptor_init_default} 291 | #define openxc_NetworkOperatorSettings_NetworkDescriptor_init_default {0, _openxc_NetworkOperatorSettings_NetworkDescriptor_NetworkType_MIN} 292 | #define openxc_NetworkDataSettings_init_default {""} 293 | #define openxc_ServerConnectSettings_init_default {"", 0} 294 | #define openxc_ModemConfigurationCommand_init_default {openxc_NetworkOperatorSettings_init_default, openxc_NetworkDataSettings_init_default, openxc_ServerConnectSettings_init_default} 295 | #define openxc_RTCConfigurationCommand_init_default {0} 296 | #define openxc_CommandResponse_init_default {_openxc_ControlCommand_Type_MIN, "", 0} 297 | #define openxc_DiagnosticRequest_init_default {0, 0, 0, 0, {0, {0}}, 0, 0, "", _openxc_DiagnosticRequest_DecodedType_MIN} 298 | #define openxc_DiagnosticResponse_init_default {0, 0, 0, 0, 0, 0, {0, {0}}, openxc_DynamicField_init_default, 0, 0} 299 | #define openxc_DynamicField_init_default {_openxc_DynamicField_Type_MIN, "", 0, 0} 300 | #define openxc_SimpleMessage_init_default {"", openxc_DynamicField_init_default, openxc_DynamicField_init_default} 301 | #define openxc_VehicleMessage_init_zero {_openxc_VehicleMessage_Type_MIN, openxc_CanMessage_init_zero, openxc_SimpleMessage_init_zero, openxc_DiagnosticResponse_init_zero, openxc_ControlCommand_init_zero, openxc_CommandResponse_init_zero, 0} 302 | #define openxc_CanMessage_init_zero {0, 0, {0, {0}}, _openxc_CanMessage_FrameFormat_MIN} 303 | #define openxc_ControlCommand_init_zero {_openxc_ControlCommand_Type_MIN, openxc_DiagnosticControlCommand_init_zero, openxc_PassthroughModeControlCommand_init_zero, openxc_AcceptanceFilterBypassCommand_init_zero, openxc_PayloadFormatCommand_init_zero, openxc_PredefinedObd2RequestsCommand_init_zero, openxc_ModemConfigurationCommand_init_zero, openxc_RTCConfigurationCommand_init_zero} 304 | #define openxc_DiagnosticControlCommand_init_zero {openxc_DiagnosticRequest_init_zero, _openxc_DiagnosticControlCommand_Action_MIN} 305 | #define openxc_PassthroughModeControlCommand_init_zero {0, 0} 306 | #define openxc_AcceptanceFilterBypassCommand_init_zero {0, 0} 307 | #define openxc_PayloadFormatCommand_init_zero {_openxc_PayloadFormatCommand_PayloadFormat_MIN} 308 | #define openxc_PredefinedObd2RequestsCommand_init_zero {0} 309 | #define openxc_NetworkOperatorSettings_init_zero {0, _openxc_NetworkOperatorSettings_OperatorSelectMode_MIN, openxc_NetworkOperatorSettings_NetworkDescriptor_init_zero} 310 | #define openxc_NetworkOperatorSettings_NetworkDescriptor_init_zero {0, _openxc_NetworkOperatorSettings_NetworkDescriptor_NetworkType_MIN} 311 | #define openxc_NetworkDataSettings_init_zero {""} 312 | #define openxc_ServerConnectSettings_init_zero {"", 0} 313 | #define openxc_ModemConfigurationCommand_init_zero {openxc_NetworkOperatorSettings_init_zero, openxc_NetworkDataSettings_init_zero, openxc_ServerConnectSettings_init_zero} 314 | #define openxc_RTCConfigurationCommand_init_zero {0} 315 | #define openxc_CommandResponse_init_zero {_openxc_ControlCommand_Type_MIN, "", 0} 316 | #define openxc_DiagnosticRequest_init_zero {0, 0, 0, 0, {0, {0}}, 0, 0, "", _openxc_DiagnosticRequest_DecodedType_MIN} 317 | #define openxc_DiagnosticResponse_init_zero {0, 0, 0, 0, 0, 0, {0, {0}}, openxc_DynamicField_init_zero, 0, 0} 318 | #define openxc_DynamicField_init_zero {_openxc_DynamicField_Type_MIN, "", 0, 0} 319 | #define openxc_SimpleMessage_init_zero {"", openxc_DynamicField_init_zero, openxc_DynamicField_init_zero} 320 | 321 | /* Field tags (for use in manual encoding/decoding) */ 322 | #define openxc_AcceptanceFilterBypassCommand_bus_tag 1 323 | #define openxc_AcceptanceFilterBypassCommand_bypass_tag 2 324 | #define openxc_CanMessage_bus_tag 1 325 | #define openxc_CanMessage_id_tag 2 326 | #define openxc_CanMessage_data_tag 3 327 | #define openxc_CanMessage_frame_format_tag 4 328 | #define openxc_CommandResponse_type_tag 1 329 | #define openxc_CommandResponse_message_tag 2 330 | #define openxc_CommandResponse_status_tag 3 331 | #define openxc_DiagnosticRequest_bus_tag 1 332 | #define openxc_DiagnosticRequest_message_id_tag 2 333 | #define openxc_DiagnosticRequest_mode_tag 3 334 | #define openxc_DiagnosticRequest_pid_tag 4 335 | #define openxc_DiagnosticRequest_payload_tag 5 336 | #define openxc_DiagnosticRequest_multiple_responses_tag 6 337 | #define openxc_DiagnosticRequest_frequency_tag 7 338 | #define openxc_DiagnosticRequest_name_tag 8 339 | #define openxc_DiagnosticRequest_decoded_type_tag 9 340 | #define openxc_DynamicField_type_tag 1 341 | #define openxc_DynamicField_string_value_tag 2 342 | #define openxc_DynamicField_numeric_value_tag 3 343 | #define openxc_DynamicField_boolean_value_tag 4 344 | #define openxc_NetworkDataSettings_apn_tag 1 345 | #define openxc_NetworkOperatorSettings_NetworkDescriptor_PLMN_tag 1 346 | #define openxc_NetworkOperatorSettings_NetworkDescriptor_networkType_tag 2 347 | #define openxc_PassthroughModeControlCommand_bus_tag 1 348 | #define openxc_PassthroughModeControlCommand_enabled_tag 2 349 | #define openxc_PayloadFormatCommand_format_tag 1 350 | #define openxc_PredefinedObd2RequestsCommand_enabled_tag 1 351 | #define openxc_RTCConfigurationCommand_unix_time_tag 1 352 | #define openxc_ServerConnectSettings_host_tag 1 353 | #define openxc_ServerConnectSettings_port_tag 2 354 | #define openxc_DiagnosticControlCommand_request_tag 1 355 | #define openxc_DiagnosticControlCommand_action_tag 2 356 | #define openxc_DiagnosticResponse_bus_tag 1 357 | #define openxc_DiagnosticResponse_message_id_tag 2 358 | #define openxc_DiagnosticResponse_mode_tag 3 359 | #define openxc_DiagnosticResponse_pid_tag 4 360 | #define openxc_DiagnosticResponse_success_tag 5 361 | #define openxc_DiagnosticResponse_negative_response_code_tag 6 362 | #define openxc_DiagnosticResponse_payload_tag 7 363 | #define openxc_DiagnosticResponse_value_tag 8 364 | #define openxc_DiagnosticResponse_frame_tag 9 365 | #define openxc_DiagnosticResponse_total_size_tag 10 366 | #define openxc_NetworkOperatorSettings_allowDataRoaming_tag 1 367 | #define openxc_NetworkOperatorSettings_operatorSelectMode_tag 2 368 | #define openxc_NetworkOperatorSettings_networkDescriptor_tag 3 369 | #define openxc_SimpleMessage_name_tag 1 370 | #define openxc_SimpleMessage_value_tag 2 371 | #define openxc_SimpleMessage_event_tag 3 372 | #define openxc_ModemConfigurationCommand_networkOperatorSettings_tag 1 373 | #define openxc_ModemConfigurationCommand_networkDataSettings_tag 2 374 | #define openxc_ModemConfigurationCommand_serverConnectSettings_tag 3 375 | #define openxc_ControlCommand_type_tag 1 376 | #define openxc_ControlCommand_diagnostic_request_tag 2 377 | #define openxc_ControlCommand_passthrough_mode_request_tag 3 378 | #define openxc_ControlCommand_acceptance_filter_bypass_command_tag 4 379 | #define openxc_ControlCommand_payload_format_command_tag 5 380 | #define openxc_ControlCommand_predefined_obd2_requests_command_tag 6 381 | #define openxc_ControlCommand_modem_configuration_command_tag 7 382 | #define openxc_ControlCommand_rtc_configuration_command_tag 8 383 | #define openxc_VehicleMessage_type_tag 1 384 | #define openxc_VehicleMessage_can_message_tag 2 385 | #define openxc_VehicleMessage_simple_message_tag 3 386 | #define openxc_VehicleMessage_diagnostic_response_tag 4 387 | #define openxc_VehicleMessage_control_command_tag 5 388 | #define openxc_VehicleMessage_command_response_tag 6 389 | #define openxc_VehicleMessage_timestamp_tag 7 390 | 391 | /* Struct field encoding specification for nanopb */ 392 | #define openxc_VehicleMessage_FIELDLIST(X, a) \ 393 | X(a, STATIC, SINGULAR, UENUM, type, 1) \ 394 | X(a, STATIC, SINGULAR, MESSAGE, can_message, 2) \ 395 | X(a, STATIC, SINGULAR, MESSAGE, simple_message, 3) \ 396 | X(a, STATIC, SINGULAR, MESSAGE, diagnostic_response, 4) \ 397 | X(a, STATIC, SINGULAR, MESSAGE, control_command, 5) \ 398 | X(a, STATIC, SINGULAR, MESSAGE, command_response, 6) \ 399 | X(a, STATIC, SINGULAR, UINT64, timestamp, 7) 400 | #define openxc_VehicleMessage_CALLBACK NULL 401 | #define openxc_VehicleMessage_DEFAULT NULL 402 | #define openxc_VehicleMessage_can_message_MSGTYPE openxc_CanMessage 403 | #define openxc_VehicleMessage_simple_message_MSGTYPE openxc_SimpleMessage 404 | #define openxc_VehicleMessage_diagnostic_response_MSGTYPE openxc_DiagnosticResponse 405 | #define openxc_VehicleMessage_control_command_MSGTYPE openxc_ControlCommand 406 | #define openxc_VehicleMessage_command_response_MSGTYPE openxc_CommandResponse 407 | 408 | #define openxc_CanMessage_FIELDLIST(X, a) \ 409 | X(a, STATIC, SINGULAR, INT32, bus, 1) \ 410 | X(a, STATIC, SINGULAR, UINT32, id, 2) \ 411 | X(a, STATIC, SINGULAR, BYTES, data, 3) \ 412 | X(a, STATIC, SINGULAR, UENUM, frame_format, 4) 413 | #define openxc_CanMessage_CALLBACK NULL 414 | #define openxc_CanMessage_DEFAULT NULL 415 | 416 | #define openxc_ControlCommand_FIELDLIST(X, a) \ 417 | X(a, STATIC, SINGULAR, UENUM, type, 1) \ 418 | X(a, STATIC, SINGULAR, MESSAGE, diagnostic_request, 2) \ 419 | X(a, STATIC, SINGULAR, MESSAGE, passthrough_mode_request, 3) \ 420 | X(a, STATIC, SINGULAR, MESSAGE, acceptance_filter_bypass_command, 4) \ 421 | X(a, STATIC, SINGULAR, MESSAGE, payload_format_command, 5) \ 422 | X(a, STATIC, SINGULAR, MESSAGE, predefined_obd2_requests_command, 6) \ 423 | X(a, STATIC, SINGULAR, MESSAGE, modem_configuration_command, 7) \ 424 | X(a, STATIC, SINGULAR, MESSAGE, rtc_configuration_command, 8) 425 | #define openxc_ControlCommand_CALLBACK NULL 426 | #define openxc_ControlCommand_DEFAULT NULL 427 | #define openxc_ControlCommand_diagnostic_request_MSGTYPE openxc_DiagnosticControlCommand 428 | #define openxc_ControlCommand_passthrough_mode_request_MSGTYPE openxc_PassthroughModeControlCommand 429 | #define openxc_ControlCommand_acceptance_filter_bypass_command_MSGTYPE openxc_AcceptanceFilterBypassCommand 430 | #define openxc_ControlCommand_payload_format_command_MSGTYPE openxc_PayloadFormatCommand 431 | #define openxc_ControlCommand_predefined_obd2_requests_command_MSGTYPE openxc_PredefinedObd2RequestsCommand 432 | #define openxc_ControlCommand_modem_configuration_command_MSGTYPE openxc_ModemConfigurationCommand 433 | #define openxc_ControlCommand_rtc_configuration_command_MSGTYPE openxc_RTCConfigurationCommand 434 | 435 | #define openxc_DiagnosticControlCommand_FIELDLIST(X, a) \ 436 | X(a, STATIC, SINGULAR, MESSAGE, request, 1) \ 437 | X(a, STATIC, SINGULAR, UENUM, action, 2) 438 | #define openxc_DiagnosticControlCommand_CALLBACK NULL 439 | #define openxc_DiagnosticControlCommand_DEFAULT NULL 440 | #define openxc_DiagnosticControlCommand_request_MSGTYPE openxc_DiagnosticRequest 441 | 442 | #define openxc_PassthroughModeControlCommand_FIELDLIST(X, a) \ 443 | X(a, STATIC, SINGULAR, INT32, bus, 1) \ 444 | X(a, STATIC, SINGULAR, BOOL, enabled, 2) 445 | #define openxc_PassthroughModeControlCommand_CALLBACK NULL 446 | #define openxc_PassthroughModeControlCommand_DEFAULT NULL 447 | 448 | #define openxc_AcceptanceFilterBypassCommand_FIELDLIST(X, a) \ 449 | X(a, STATIC, SINGULAR, INT32, bus, 1) \ 450 | X(a, STATIC, SINGULAR, BOOL, bypass, 2) 451 | #define openxc_AcceptanceFilterBypassCommand_CALLBACK NULL 452 | #define openxc_AcceptanceFilterBypassCommand_DEFAULT NULL 453 | 454 | #define openxc_PayloadFormatCommand_FIELDLIST(X, a) \ 455 | X(a, STATIC, SINGULAR, UENUM, format, 1) 456 | #define openxc_PayloadFormatCommand_CALLBACK NULL 457 | #define openxc_PayloadFormatCommand_DEFAULT NULL 458 | 459 | #define openxc_PredefinedObd2RequestsCommand_FIELDLIST(X, a) \ 460 | X(a, STATIC, SINGULAR, BOOL, enabled, 1) 461 | #define openxc_PredefinedObd2RequestsCommand_CALLBACK NULL 462 | #define openxc_PredefinedObd2RequestsCommand_DEFAULT NULL 463 | 464 | #define openxc_NetworkOperatorSettings_FIELDLIST(X, a) \ 465 | X(a, STATIC, SINGULAR, BOOL, allowDataRoaming, 1) \ 466 | X(a, STATIC, SINGULAR, UENUM, operatorSelectMode, 2) \ 467 | X(a, STATIC, SINGULAR, MESSAGE, networkDescriptor, 3) 468 | #define openxc_NetworkOperatorSettings_CALLBACK NULL 469 | #define openxc_NetworkOperatorSettings_DEFAULT NULL 470 | #define openxc_NetworkOperatorSettings_networkDescriptor_MSGTYPE openxc_NetworkOperatorSettings_NetworkDescriptor 471 | 472 | #define openxc_NetworkOperatorSettings_NetworkDescriptor_FIELDLIST(X, a) \ 473 | X(a, STATIC, SINGULAR, UINT32, PLMN, 1) \ 474 | X(a, STATIC, SINGULAR, UENUM, networkType, 2) 475 | #define openxc_NetworkOperatorSettings_NetworkDescriptor_CALLBACK NULL 476 | #define openxc_NetworkOperatorSettings_NetworkDescriptor_DEFAULT NULL 477 | 478 | #define openxc_NetworkDataSettings_FIELDLIST(X, a) \ 479 | X(a, STATIC, SINGULAR, STRING, apn, 1) 480 | #define openxc_NetworkDataSettings_CALLBACK NULL 481 | #define openxc_NetworkDataSettings_DEFAULT NULL 482 | 483 | #define openxc_ServerConnectSettings_FIELDLIST(X, a) \ 484 | X(a, STATIC, SINGULAR, STRING, host, 1) \ 485 | X(a, STATIC, SINGULAR, UINT32, port, 2) 486 | #define openxc_ServerConnectSettings_CALLBACK NULL 487 | #define openxc_ServerConnectSettings_DEFAULT NULL 488 | 489 | #define openxc_ModemConfigurationCommand_FIELDLIST(X, a) \ 490 | X(a, STATIC, SINGULAR, MESSAGE, networkOperatorSettings, 1) \ 491 | X(a, STATIC, SINGULAR, MESSAGE, networkDataSettings, 2) \ 492 | X(a, STATIC, SINGULAR, MESSAGE, serverConnectSettings, 3) 493 | #define openxc_ModemConfigurationCommand_CALLBACK NULL 494 | #define openxc_ModemConfigurationCommand_DEFAULT NULL 495 | #define openxc_ModemConfigurationCommand_networkOperatorSettings_MSGTYPE openxc_NetworkOperatorSettings 496 | #define openxc_ModemConfigurationCommand_networkDataSettings_MSGTYPE openxc_NetworkDataSettings 497 | #define openxc_ModemConfigurationCommand_serverConnectSettings_MSGTYPE openxc_ServerConnectSettings 498 | 499 | #define openxc_RTCConfigurationCommand_FIELDLIST(X, a) \ 500 | X(a, STATIC, SINGULAR, UINT32, unix_time, 1) 501 | #define openxc_RTCConfigurationCommand_CALLBACK NULL 502 | #define openxc_RTCConfigurationCommand_DEFAULT NULL 503 | 504 | #define openxc_CommandResponse_FIELDLIST(X, a) \ 505 | X(a, STATIC, SINGULAR, UENUM, type, 1) \ 506 | X(a, STATIC, SINGULAR, STRING, message, 2) \ 507 | X(a, STATIC, SINGULAR, BOOL, status, 3) 508 | #define openxc_CommandResponse_CALLBACK NULL 509 | #define openxc_CommandResponse_DEFAULT NULL 510 | 511 | #define openxc_DiagnosticRequest_FIELDLIST(X, a) \ 512 | X(a, STATIC, SINGULAR, INT32, bus, 1) \ 513 | X(a, STATIC, SINGULAR, UINT32, message_id, 2) \ 514 | X(a, STATIC, SINGULAR, UINT32, mode, 3) \ 515 | X(a, STATIC, SINGULAR, UINT32, pid, 4) \ 516 | X(a, STATIC, SINGULAR, BYTES, payload, 5) \ 517 | X(a, STATIC, SINGULAR, BOOL, multiple_responses, 6) \ 518 | X(a, STATIC, SINGULAR, DOUBLE, frequency, 7) \ 519 | X(a, STATIC, SINGULAR, STRING, name, 8) \ 520 | X(a, STATIC, SINGULAR, UENUM, decoded_type, 9) 521 | #define openxc_DiagnosticRequest_CALLBACK NULL 522 | #define openxc_DiagnosticRequest_DEFAULT NULL 523 | 524 | #define openxc_DiagnosticResponse_FIELDLIST(X, a) \ 525 | X(a, STATIC, SINGULAR, INT32, bus, 1) \ 526 | X(a, STATIC, SINGULAR, UINT32, message_id, 2) \ 527 | X(a, STATIC, SINGULAR, UINT32, mode, 3) \ 528 | X(a, STATIC, SINGULAR, UINT32, pid, 4) \ 529 | X(a, STATIC, SINGULAR, BOOL, success, 5) \ 530 | X(a, STATIC, SINGULAR, UINT32, negative_response_code, 6) \ 531 | X(a, STATIC, SINGULAR, BYTES, payload, 7) \ 532 | X(a, STATIC, SINGULAR, MESSAGE, value, 8) \ 533 | X(a, STATIC, SINGULAR, INT32, frame, 9) \ 534 | X(a, STATIC, SINGULAR, UINT32, total_size, 10) 535 | #define openxc_DiagnosticResponse_CALLBACK NULL 536 | #define openxc_DiagnosticResponse_DEFAULT NULL 537 | #define openxc_DiagnosticResponse_value_MSGTYPE openxc_DynamicField 538 | 539 | #define openxc_DynamicField_FIELDLIST(X, a) \ 540 | X(a, STATIC, SINGULAR, UENUM, type, 1) \ 541 | X(a, STATIC, SINGULAR, STRING, string_value, 2) \ 542 | X(a, STATIC, SINGULAR, DOUBLE, numeric_value, 3) \ 543 | X(a, STATIC, SINGULAR, BOOL, boolean_value, 4) 544 | #define openxc_DynamicField_CALLBACK NULL 545 | #define openxc_DynamicField_DEFAULT NULL 546 | 547 | #define openxc_SimpleMessage_FIELDLIST(X, a) \ 548 | X(a, STATIC, SINGULAR, STRING, name, 1) \ 549 | X(a, STATIC, SINGULAR, MESSAGE, value, 2) \ 550 | X(a, STATIC, SINGULAR, MESSAGE, event, 3) 551 | #define openxc_SimpleMessage_CALLBACK NULL 552 | #define openxc_SimpleMessage_DEFAULT NULL 553 | #define openxc_SimpleMessage_value_MSGTYPE openxc_DynamicField 554 | #define openxc_SimpleMessage_event_MSGTYPE openxc_DynamicField 555 | 556 | extern const pb_msgdesc_t openxc_VehicleMessage_msg; 557 | extern const pb_msgdesc_t openxc_CanMessage_msg; 558 | extern const pb_msgdesc_t openxc_ControlCommand_msg; 559 | extern const pb_msgdesc_t openxc_DiagnosticControlCommand_msg; 560 | extern const pb_msgdesc_t openxc_PassthroughModeControlCommand_msg; 561 | extern const pb_msgdesc_t openxc_AcceptanceFilterBypassCommand_msg; 562 | extern const pb_msgdesc_t openxc_PayloadFormatCommand_msg; 563 | extern const pb_msgdesc_t openxc_PredefinedObd2RequestsCommand_msg; 564 | extern const pb_msgdesc_t openxc_NetworkOperatorSettings_msg; 565 | extern const pb_msgdesc_t openxc_NetworkOperatorSettings_NetworkDescriptor_msg; 566 | extern const pb_msgdesc_t openxc_NetworkDataSettings_msg; 567 | extern const pb_msgdesc_t openxc_ServerConnectSettings_msg; 568 | extern const pb_msgdesc_t openxc_ModemConfigurationCommand_msg; 569 | extern const pb_msgdesc_t openxc_RTCConfigurationCommand_msg; 570 | extern const pb_msgdesc_t openxc_CommandResponse_msg; 571 | extern const pb_msgdesc_t openxc_DiagnosticRequest_msg; 572 | extern const pb_msgdesc_t openxc_DiagnosticResponse_msg; 573 | extern const pb_msgdesc_t openxc_DynamicField_msg; 574 | extern const pb_msgdesc_t openxc_SimpleMessage_msg; 575 | 576 | /* Defines for backwards compatibility with code written before nanopb-0.4.0 */ 577 | #define openxc_VehicleMessage_fields &openxc_VehicleMessage_msg 578 | #define openxc_CanMessage_fields &openxc_CanMessage_msg 579 | #define openxc_ControlCommand_fields &openxc_ControlCommand_msg 580 | #define openxc_DiagnosticControlCommand_fields &openxc_DiagnosticControlCommand_msg 581 | #define openxc_PassthroughModeControlCommand_fields &openxc_PassthroughModeControlCommand_msg 582 | #define openxc_AcceptanceFilterBypassCommand_fields &openxc_AcceptanceFilterBypassCommand_msg 583 | #define openxc_PayloadFormatCommand_fields &openxc_PayloadFormatCommand_msg 584 | #define openxc_PredefinedObd2RequestsCommand_fields &openxc_PredefinedObd2RequestsCommand_msg 585 | #define openxc_NetworkOperatorSettings_fields &openxc_NetworkOperatorSettings_msg 586 | #define openxc_NetworkOperatorSettings_NetworkDescriptor_fields &openxc_NetworkOperatorSettings_NetworkDescriptor_msg 587 | #define openxc_NetworkDataSettings_fields &openxc_NetworkDataSettings_msg 588 | #define openxc_ServerConnectSettings_fields &openxc_ServerConnectSettings_msg 589 | #define openxc_ModemConfigurationCommand_fields &openxc_ModemConfigurationCommand_msg 590 | #define openxc_RTCConfigurationCommand_fields &openxc_RTCConfigurationCommand_msg 591 | #define openxc_CommandResponse_fields &openxc_CommandResponse_msg 592 | #define openxc_DiagnosticRequest_fields &openxc_DiagnosticRequest_msg 593 | #define openxc_DiagnosticResponse_fields &openxc_DiagnosticResponse_msg 594 | #define openxc_DynamicField_fields &openxc_DynamicField_msg 595 | #define openxc_SimpleMessage_fields &openxc_SimpleMessage_msg 596 | 597 | /* Maximum encoded size of messages (where known) */ 598 | #define openxc_VehicleMessage_size 1383 599 | #define openxc_CanMessage_size 29 600 | #define openxc_ControlCommand_size 342 601 | #define openxc_DiagnosticControlCommand_size 67 602 | #define openxc_PassthroughModeControlCommand_size 13 603 | #define openxc_AcceptanceFilterBypassCommand_size 13 604 | #define openxc_PayloadFormatCommand_size 2 605 | #define openxc_PredefinedObd2RequestsCommand_size 2 606 | #define openxc_NetworkOperatorSettings_size 14 607 | #define openxc_NetworkOperatorSettings_NetworkDescriptor_size 8 608 | #define openxc_NetworkDataSettings_size 65 609 | #define openxc_ServerConnectSettings_size 136 610 | #define openxc_ModemConfigurationCommand_size 222 611 | #define openxc_RTCConfigurationCommand_size 6 612 | #define openxc_CommandResponse_size 134 613 | #define openxc_DiagnosticRequest_size 63 614 | #define openxc_DiagnosticResponse_size 458 615 | #define openxc_DynamicField_size 143 616 | #define openxc_SimpleMessage_size 393 617 | 618 | #ifdef __cplusplus 619 | } /* extern "C" */ 620 | #endif 621 | /* @@protoc_insertion_point(eof) */ 622 | 623 | #endif 624 | -------------------------------------------------------------------------------- /gen/python/openxc_pb2.py: -------------------------------------------------------------------------------- 1 | # Generated by the protocol buffer compiler. DO NOT EDIT! 2 | # source: openxc.proto 3 | 4 | import sys 5 | _b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1')) 6 | from google.protobuf import descriptor as _descriptor 7 | from google.protobuf import message as _message 8 | from google.protobuf import reflection as _reflection 9 | from google.protobuf import symbol_database as _symbol_database 10 | from google.protobuf import descriptor_pb2 11 | # @@protoc_insertion_point(imports) 12 | 13 | _sym_db = _symbol_database.Default() 14 | 15 | 16 | 17 | 18 | DESCRIPTOR = _descriptor.FileDescriptor( 19 | name='openxc.proto', 20 | package='openxc', 21 | syntax='proto3', 22 | serialized_pb=_b('\n\x0copenxc.proto\x12\x06openxc\"\xa7\x03\n\x0eVehicleMessage\x12)\n\x04type\x18\x01 \x01(\x0e\x32\x1b.openxc.VehicleMessage.Type\x12\'\n\x0b\x63\x61n_message\x18\x02 \x01(\x0b\x32\x12.openxc.CanMessage\x12-\n\x0esimple_message\x18\x03 \x01(\x0b\x32\x15.openxc.SimpleMessage\x12\x37\n\x13\x64iagnostic_response\x18\x04 \x01(\x0b\x32\x1a.openxc.DiagnosticResponse\x12/\n\x0f\x63ontrol_command\x18\x05 \x01(\x0b\x32\x16.openxc.ControlCommand\x12\x31\n\x10\x63ommand_response\x18\x06 \x01(\x0b\x32\x17.openxc.CommandResponse\x12\x11\n\ttimestamp\x18\x07 \x01(\x04\"b\n\x04Type\x12\n\n\x06UNUSED\x10\x00\x12\x07\n\x03\x43\x41N\x10\x01\x12\n\n\x06SIMPLE\x10\x02\x12\x0e\n\nDIAGNOSTIC\x10\x03\x12\x13\n\x0f\x43ONTROL_COMMAND\x10\x04\x12\x14\n\x10\x43OMMAND_RESPONSE\x10\x05\"\xa0\x01\n\nCanMessage\x12\x0b\n\x03\x62us\x18\x01 \x01(\x05\x12\n\n\x02id\x18\x02 \x01(\r\x12\x0c\n\x04\x64\x61ta\x18\x03 \x01(\x0c\x12\x34\n\x0c\x66rame_format\x18\x04 \x01(\x0e\x32\x1e.openxc.CanMessage.FrameFormat\"5\n\x0b\x46rameFormat\x12\n\n\x06UNUSED\x10\x00\x12\x0c\n\x08STANDARD\x10\x01\x12\x0c\n\x08\x45XTENDED\x10\x02\"\xa3\x06\n\x0e\x43ontrolCommand\x12)\n\x04type\x18\x01 \x01(\x0e\x32\x1b.openxc.ControlCommand.Type\x12<\n\x12\x64iagnostic_request\x18\x02 \x01(\x0b\x32 .openxc.DiagnosticControlCommand\x12G\n\x18passthrough_mode_request\x18\x03 \x01(\x0b\x32%.openxc.PassthroughModeControlCommand\x12O\n acceptance_filter_bypass_command\x18\x04 \x01(\x0b\x32%.openxc.AcceptanceFilterBypassCommand\x12<\n\x16payload_format_command\x18\x05 \x01(\x0b\x32\x1c.openxc.PayloadFormatCommand\x12O\n predefined_obd2_requests_command\x18\x06 \x01(\x0b\x32%.openxc.PredefinedObd2RequestsCommand\x12\x46\n\x1bmodem_configuration_command\x18\x07 \x01(\x0b\x32!.openxc.ModemConfigurationCommand\x12\x42\n\x19rtc_configuration_command\x18\x08 \x01(\x0b\x32\x1f.openxc.RTCConfigurationCommand\"\xf2\x01\n\x04Type\x12\n\n\x06UNUSED\x10\x00\x12\x0b\n\x07VERSION\x10\x01\x12\r\n\tDEVICE_ID\x10\x02\x12\x0e\n\nDIAGNOSTIC\x10\x03\x12\x0f\n\x0bPASSTHROUGH\x10\x04\x12\x1c\n\x18\x41\x43\x43\x45PTANCE_FILTER_BYPASS\x10\x05\x12\x12\n\x0ePAYLOAD_FORMAT\x10\x06\x12\x1c\n\x18PREDEFINED_OBD2_REQUESTS\x10\x07\x12\x17\n\x13MODEM_CONFIGURATION\x10\x08\x12\x15\n\x11RTC_CONFIGURATION\x10\t\x12\x13\n\x0fSD_MOUNT_STATUS\x10\n\x12\x0c\n\x08PLATFORM\x10\x0b\"\xaa\x01\n\x18\x44iagnosticControlCommand\x12*\n\x07request\x18\x01 \x01(\x0b\x32\x19.openxc.DiagnosticRequest\x12\x37\n\x06\x61\x63tion\x18\x02 \x01(\x0e\x32\'.openxc.DiagnosticControlCommand.Action\")\n\x06\x41\x63tion\x12\n\n\x06UNUSED\x10\x00\x12\x07\n\x03\x41\x44\x44\x10\x01\x12\n\n\x06\x43\x41NCEL\x10\x02\"=\n\x1dPassthroughModeControlCommand\x12\x0b\n\x03\x62us\x18\x01 \x01(\x05\x12\x0f\n\x07\x65nabled\x18\x02 \x01(\x08\"<\n\x1d\x41\x63\x63\x65ptanceFilterBypassCommand\x12\x0b\n\x03\x62us\x18\x01 \x01(\x05\x12\x0e\n\x06\x62ypass\x18\x02 \x01(\x08\"\x98\x01\n\x14PayloadFormatCommand\x12:\n\x06\x66ormat\x18\x01 \x01(\x0e\x32*.openxc.PayloadFormatCommand.PayloadFormat\"D\n\rPayloadFormat\x12\n\n\x06UNUSED\x10\x00\x12\x08\n\x04JSON\x10\x01\x12\x0c\n\x08PROTOBUF\x10\x02\x12\x0f\n\x0bMESSAGEPACK\x10\x03\"0\n\x1dPredefinedObd2RequestsCommand\x12\x0f\n\x07\x65nabled\x18\x01 \x01(\x08\"\xd1\x03\n\x17NetworkOperatorSettings\x12\x18\n\x10\x61llowDataRoaming\x18\x01 \x01(\x08\x12N\n\x12operatorSelectMode\x18\x02 \x01(\x0e\x32\x32.openxc.NetworkOperatorSettings.OperatorSelectMode\x12L\n\x11networkDescriptor\x18\x03 \x01(\x0b\x32\x31.openxc.NetworkOperatorSettings.NetworkDescriptor\x1a\x98\x01\n\x11NetworkDescriptor\x12\x0c\n\x04PLMN\x18\x01 \x01(\r\x12R\n\x0bnetworkType\x18\x02 \x01(\x0e\x32=.openxc.NetworkOperatorSettings.NetworkDescriptor.NetworkType\"!\n\x0bNetworkType\x12\x07\n\x03GSM\x10\x00\x12\t\n\x05UTRAN\x10\x02\"c\n\x12OperatorSelectMode\x12\r\n\tAUTOMATIC\x10\x00\x12\n\n\x06MANUAL\x10\x01\x12\x0e\n\nDEREGISTER\x10\x02\x12\x0c\n\x08SET_ONLY\x10\x03\x12\x14\n\x10MANUAL_AUTOMATIC\x10\x04\"\"\n\x13NetworkDataSettings\x12\x0b\n\x03\x61pn\x18\x01 \x01(\t\"3\n\x15ServerConnectSettings\x12\x0c\n\x04host\x18\x01 \x01(\t\x12\x0c\n\x04port\x18\x02 \x01(\r\"\xd5\x01\n\x19ModemConfigurationCommand\x12@\n\x17networkOperatorSettings\x18\x01 \x01(\x0b\x32\x1f.openxc.NetworkOperatorSettings\x12\x38\n\x13networkDataSettings\x18\x02 \x01(\x0b\x32\x1b.openxc.NetworkDataSettings\x12<\n\x15serverConnectSettings\x18\x03 \x01(\x0b\x32\x1d.openxc.ServerConnectSettings\",\n\x17RTCConfigurationCommand\x12\x11\n\tunix_time\x18\x01 \x01(\r\"]\n\x0f\x43ommandResponse\x12)\n\x04type\x18\x01 \x01(\x0e\x32\x1b.openxc.ControlCommand.Type\x12\x0f\n\x07message\x18\x02 \x01(\t\x12\x0e\n\x06status\x18\x03 \x01(\x08\"\x89\x02\n\x11\x44iagnosticRequest\x12\x0b\n\x03\x62us\x18\x01 \x01(\x05\x12\x12\n\nmessage_id\x18\x02 \x01(\r\x12\x0c\n\x04mode\x18\x03 \x01(\r\x12\x0b\n\x03pid\x18\x04 \x01(\r\x12\x0f\n\x07payload\x18\x05 \x01(\x0c\x12\x1a\n\x12multiple_responses\x18\x06 \x01(\x08\x12\x11\n\tfrequency\x18\x07 \x01(\x01\x12\x0c\n\x04name\x18\x08 \x01(\t\x12;\n\x0c\x64\x65\x63oded_type\x18\t \x01(\x0e\x32%.openxc.DiagnosticRequest.DecodedType\"-\n\x0b\x44\x65\x63odedType\x12\n\n\x06UNUSED\x10\x00\x12\x08\n\x04NONE\x10\x01\x12\x08\n\x04OBD2\x10\x02\"\xb7\x01\n\x12\x44iagnosticResponse\x12\x0b\n\x03\x62us\x18\x01 \x01(\x05\x12\x12\n\nmessage_id\x18\x02 \x01(\r\x12\x0c\n\x04mode\x18\x03 \x01(\r\x12\x0b\n\x03pid\x18\x04 \x01(\r\x12\x0f\n\x07success\x18\x05 \x01(\x08\x12\x1e\n\x16negative_response_code\x18\x06 \x01(\r\x12\x0f\n\x07payload\x18\x07 \x01(\x0c\x12#\n\x05value\x18\x08 \x01(\x0b\x32\x14.openxc.DynamicField\"\xae\x01\n\x0c\x44ynamicField\x12\'\n\x04type\x18\x01 \x01(\x0e\x32\x19.openxc.DynamicField.Type\x12\x14\n\x0cstring_value\x18\x02 \x01(\t\x12\x15\n\rnumeric_value\x18\x03 \x01(\x01\x12\x15\n\rboolean_value\x18\x04 \x01(\x08\"1\n\x04Type\x12\n\n\x06UNUSED\x10\x00\x12\n\n\x06STRING\x10\x01\x12\x07\n\x03NUM\x10\x02\x12\x08\n\x04\x42OOL\x10\x03\"g\n\rSimpleMessage\x12\x0c\n\x04name\x18\x01 \x01(\t\x12#\n\x05value\x18\x02 \x01(\x0b\x32\x14.openxc.DynamicField\x12#\n\x05\x65vent\x18\x03 \x01(\x0b\x32\x14.openxc.DynamicFieldB\x1c\n\ncom.openxcB\x0e\x42inaryMessagesb\x06proto3') 23 | ) 24 | _sym_db.RegisterFileDescriptor(DESCRIPTOR) 25 | 26 | 27 | 28 | _VEHICLEMESSAGE_TYPE = _descriptor.EnumDescriptor( 29 | name='Type', 30 | full_name='openxc.VehicleMessage.Type', 31 | filename=None, 32 | file=DESCRIPTOR, 33 | values=[ 34 | _descriptor.EnumValueDescriptor( 35 | name='UNUSED', index=0, number=0, 36 | options=None, 37 | type=None), 38 | _descriptor.EnumValueDescriptor( 39 | name='CAN', index=1, number=1, 40 | options=None, 41 | type=None), 42 | _descriptor.EnumValueDescriptor( 43 | name='SIMPLE', index=2, number=2, 44 | options=None, 45 | type=None), 46 | _descriptor.EnumValueDescriptor( 47 | name='DIAGNOSTIC', index=3, number=3, 48 | options=None, 49 | type=None), 50 | _descriptor.EnumValueDescriptor( 51 | name='CONTROL_COMMAND', index=4, number=4, 52 | options=None, 53 | type=None), 54 | _descriptor.EnumValueDescriptor( 55 | name='COMMAND_RESPONSE', index=5, number=5, 56 | options=None, 57 | type=None), 58 | ], 59 | containing_type=None, 60 | options=None, 61 | serialized_start=350, 62 | serialized_end=448, 63 | ) 64 | _sym_db.RegisterEnumDescriptor(_VEHICLEMESSAGE_TYPE) 65 | 66 | _CANMESSAGE_FRAMEFORMAT = _descriptor.EnumDescriptor( 67 | name='FrameFormat', 68 | full_name='openxc.CanMessage.FrameFormat', 69 | filename=None, 70 | file=DESCRIPTOR, 71 | values=[ 72 | _descriptor.EnumValueDescriptor( 73 | name='UNUSED', index=0, number=0, 74 | options=None, 75 | type=None), 76 | _descriptor.EnumValueDescriptor( 77 | name='STANDARD', index=1, number=1, 78 | options=None, 79 | type=None), 80 | _descriptor.EnumValueDescriptor( 81 | name='EXTENDED', index=2, number=2, 82 | options=None, 83 | type=None), 84 | ], 85 | containing_type=None, 86 | options=None, 87 | serialized_start=558, 88 | serialized_end=611, 89 | ) 90 | _sym_db.RegisterEnumDescriptor(_CANMESSAGE_FRAMEFORMAT) 91 | 92 | _CONTROLCOMMAND_TYPE = _descriptor.EnumDescriptor( 93 | name='Type', 94 | full_name='openxc.ControlCommand.Type', 95 | filename=None, 96 | file=DESCRIPTOR, 97 | values=[ 98 | _descriptor.EnumValueDescriptor( 99 | name='UNUSED', index=0, number=0, 100 | options=None, 101 | type=None), 102 | _descriptor.EnumValueDescriptor( 103 | name='VERSION', index=1, number=1, 104 | options=None, 105 | type=None), 106 | _descriptor.EnumValueDescriptor( 107 | name='DEVICE_ID', index=2, number=2, 108 | options=None, 109 | type=None), 110 | _descriptor.EnumValueDescriptor( 111 | name='DIAGNOSTIC', index=3, number=3, 112 | options=None, 113 | type=None), 114 | _descriptor.EnumValueDescriptor( 115 | name='PASSTHROUGH', index=4, number=4, 116 | options=None, 117 | type=None), 118 | _descriptor.EnumValueDescriptor( 119 | name='ACCEPTANCE_FILTER_BYPASS', index=5, number=5, 120 | options=None, 121 | type=None), 122 | _descriptor.EnumValueDescriptor( 123 | name='PAYLOAD_FORMAT', index=6, number=6, 124 | options=None, 125 | type=None), 126 | _descriptor.EnumValueDescriptor( 127 | name='PREDEFINED_OBD2_REQUESTS', index=7, number=7, 128 | options=None, 129 | type=None), 130 | _descriptor.EnumValueDescriptor( 131 | name='MODEM_CONFIGURATION', index=8, number=8, 132 | options=None, 133 | type=None), 134 | _descriptor.EnumValueDescriptor( 135 | name='RTC_CONFIGURATION', index=9, number=9, 136 | options=None, 137 | type=None), 138 | _descriptor.EnumValueDescriptor( 139 | name='SD_MOUNT_STATUS', index=10, number=10, 140 | options=None, 141 | type=None), 142 | _descriptor.EnumValueDescriptor( 143 | name='PLATFORM', index=11, number=11, 144 | options=None, 145 | type=None), 146 | ], 147 | containing_type=None, 148 | options=None, 149 | serialized_start=1175, 150 | serialized_end=1417, 151 | ) 152 | _sym_db.RegisterEnumDescriptor(_CONTROLCOMMAND_TYPE) 153 | 154 | _DIAGNOSTICCONTROLCOMMAND_ACTION = _descriptor.EnumDescriptor( 155 | name='Action', 156 | full_name='openxc.DiagnosticControlCommand.Action', 157 | filename=None, 158 | file=DESCRIPTOR, 159 | values=[ 160 | _descriptor.EnumValueDescriptor( 161 | name='UNUSED', index=0, number=0, 162 | options=None, 163 | type=None), 164 | _descriptor.EnumValueDescriptor( 165 | name='ADD', index=1, number=1, 166 | options=None, 167 | type=None), 168 | _descriptor.EnumValueDescriptor( 169 | name='CANCEL', index=2, number=2, 170 | options=None, 171 | type=None), 172 | ], 173 | containing_type=None, 174 | options=None, 175 | serialized_start=1549, 176 | serialized_end=1590, 177 | ) 178 | _sym_db.RegisterEnumDescriptor(_DIAGNOSTICCONTROLCOMMAND_ACTION) 179 | 180 | _PAYLOADFORMATCOMMAND_PAYLOADFORMAT = _descriptor.EnumDescriptor( 181 | name='PayloadFormat', 182 | full_name='openxc.PayloadFormatCommand.PayloadFormat', 183 | filename=None, 184 | file=DESCRIPTOR, 185 | values=[ 186 | _descriptor.EnumValueDescriptor( 187 | name='UNUSED', index=0, number=0, 188 | options=None, 189 | type=None), 190 | _descriptor.EnumValueDescriptor( 191 | name='JSON', index=1, number=1, 192 | options=None, 193 | type=None), 194 | _descriptor.EnumValueDescriptor( 195 | name='PROTOBUF', index=2, number=2, 196 | options=None, 197 | type=None), 198 | _descriptor.EnumValueDescriptor( 199 | name='MESSAGEPACK', index=3, number=3, 200 | options=None, 201 | type=None), 202 | ], 203 | containing_type=None, 204 | options=None, 205 | serialized_start=1802, 206 | serialized_end=1870, 207 | ) 208 | _sym_db.RegisterEnumDescriptor(_PAYLOADFORMATCOMMAND_PAYLOADFORMAT) 209 | 210 | _NETWORKOPERATORSETTINGS_NETWORKDESCRIPTOR_NETWORKTYPE = _descriptor.EnumDescriptor( 211 | name='NetworkType', 212 | full_name='openxc.NetworkOperatorSettings.NetworkDescriptor.NetworkType', 213 | filename=None, 214 | file=DESCRIPTOR, 215 | values=[ 216 | _descriptor.EnumValueDescriptor( 217 | name='GSM', index=0, number=0, 218 | options=None, 219 | type=None), 220 | _descriptor.EnumValueDescriptor( 221 | name='UTRAN', index=1, number=2, 222 | options=None, 223 | type=None), 224 | ], 225 | containing_type=None, 226 | options=None, 227 | serialized_start=2254, 228 | serialized_end=2287, 229 | ) 230 | _sym_db.RegisterEnumDescriptor(_NETWORKOPERATORSETTINGS_NETWORKDESCRIPTOR_NETWORKTYPE) 231 | 232 | _NETWORKOPERATORSETTINGS_OPERATORSELECTMODE = _descriptor.EnumDescriptor( 233 | name='OperatorSelectMode', 234 | full_name='openxc.NetworkOperatorSettings.OperatorSelectMode', 235 | filename=None, 236 | file=DESCRIPTOR, 237 | values=[ 238 | _descriptor.EnumValueDescriptor( 239 | name='AUTOMATIC', index=0, number=0, 240 | options=None, 241 | type=None), 242 | _descriptor.EnumValueDescriptor( 243 | name='MANUAL', index=1, number=1, 244 | options=None, 245 | type=None), 246 | _descriptor.EnumValueDescriptor( 247 | name='DEREGISTER', index=2, number=2, 248 | options=None, 249 | type=None), 250 | _descriptor.EnumValueDescriptor( 251 | name='SET_ONLY', index=3, number=3, 252 | options=None, 253 | type=None), 254 | _descriptor.EnumValueDescriptor( 255 | name='MANUAL_AUTOMATIC', index=4, number=4, 256 | options=None, 257 | type=None), 258 | ], 259 | containing_type=None, 260 | options=None, 261 | serialized_start=2289, 262 | serialized_end=2388, 263 | ) 264 | _sym_db.RegisterEnumDescriptor(_NETWORKOPERATORSETTINGS_OPERATORSELECTMODE) 265 | 266 | _DIAGNOSTICREQUEST_DECODEDTYPE = _descriptor.EnumDescriptor( 267 | name='DecodedType', 268 | full_name='openxc.DiagnosticRequest.DecodedType', 269 | filename=None, 270 | file=DESCRIPTOR, 271 | values=[ 272 | _descriptor.EnumValueDescriptor( 273 | name='UNUSED', index=0, number=0, 274 | options=None, 275 | type=None), 276 | _descriptor.EnumValueDescriptor( 277 | name='NONE', index=1, number=1, 278 | options=None, 279 | type=None), 280 | _descriptor.EnumValueDescriptor( 281 | name='OBD2', index=2, number=2, 282 | options=None, 283 | type=None), 284 | ], 285 | containing_type=None, 286 | options=None, 287 | serialized_start=3057, 288 | serialized_end=3102, 289 | ) 290 | _sym_db.RegisterEnumDescriptor(_DIAGNOSTICREQUEST_DECODEDTYPE) 291 | 292 | _DYNAMICFIELD_TYPE = _descriptor.EnumDescriptor( 293 | name='Type', 294 | full_name='openxc.DynamicField.Type', 295 | filename=None, 296 | file=DESCRIPTOR, 297 | values=[ 298 | _descriptor.EnumValueDescriptor( 299 | name='UNUSED', index=0, number=0, 300 | options=None, 301 | type=None), 302 | _descriptor.EnumValueDescriptor( 303 | name='STRING', index=1, number=1, 304 | options=None, 305 | type=None), 306 | _descriptor.EnumValueDescriptor( 307 | name='NUM', index=2, number=2, 308 | options=None, 309 | type=None), 310 | _descriptor.EnumValueDescriptor( 311 | name='BOOL', index=3, number=3, 312 | options=None, 313 | type=None), 314 | ], 315 | containing_type=None, 316 | options=None, 317 | serialized_start=3416, 318 | serialized_end=3465, 319 | ) 320 | _sym_db.RegisterEnumDescriptor(_DYNAMICFIELD_TYPE) 321 | 322 | 323 | _VEHICLEMESSAGE = _descriptor.Descriptor( 324 | name='VehicleMessage', 325 | full_name='openxc.VehicleMessage', 326 | filename=None, 327 | file=DESCRIPTOR, 328 | containing_type=None, 329 | fields=[ 330 | _descriptor.FieldDescriptor( 331 | name='type', full_name='openxc.VehicleMessage.type', index=0, 332 | number=1, type=14, cpp_type=8, label=1, 333 | has_default_value=False, default_value=0, 334 | message_type=None, enum_type=None, containing_type=None, 335 | is_extension=False, extension_scope=None, 336 | options=None), 337 | _descriptor.FieldDescriptor( 338 | name='can_message', full_name='openxc.VehicleMessage.can_message', index=1, 339 | number=2, type=11, cpp_type=10, label=1, 340 | has_default_value=False, default_value=None, 341 | message_type=None, enum_type=None, containing_type=None, 342 | is_extension=False, extension_scope=None, 343 | options=None), 344 | _descriptor.FieldDescriptor( 345 | name='simple_message', full_name='openxc.VehicleMessage.simple_message', index=2, 346 | number=3, type=11, cpp_type=10, label=1, 347 | has_default_value=False, default_value=None, 348 | message_type=None, enum_type=None, containing_type=None, 349 | is_extension=False, extension_scope=None, 350 | options=None), 351 | _descriptor.FieldDescriptor( 352 | name='diagnostic_response', full_name='openxc.VehicleMessage.diagnostic_response', index=3, 353 | number=4, type=11, cpp_type=10, label=1, 354 | has_default_value=False, default_value=None, 355 | message_type=None, enum_type=None, containing_type=None, 356 | is_extension=False, extension_scope=None, 357 | options=None), 358 | _descriptor.FieldDescriptor( 359 | name='control_command', full_name='openxc.VehicleMessage.control_command', index=4, 360 | number=5, type=11, cpp_type=10, label=1, 361 | has_default_value=False, default_value=None, 362 | message_type=None, enum_type=None, containing_type=None, 363 | is_extension=False, extension_scope=None, 364 | options=None), 365 | _descriptor.FieldDescriptor( 366 | name='command_response', full_name='openxc.VehicleMessage.command_response', index=5, 367 | number=6, type=11, cpp_type=10, label=1, 368 | has_default_value=False, default_value=None, 369 | message_type=None, enum_type=None, containing_type=None, 370 | is_extension=False, extension_scope=None, 371 | options=None), 372 | _descriptor.FieldDescriptor( 373 | name='timestamp', full_name='openxc.VehicleMessage.timestamp', index=6, 374 | number=7, type=4, cpp_type=4, label=1, 375 | has_default_value=False, default_value=0, 376 | message_type=None, enum_type=None, containing_type=None, 377 | is_extension=False, extension_scope=None, 378 | options=None), 379 | ], 380 | extensions=[ 381 | ], 382 | nested_types=[], 383 | enum_types=[ 384 | _VEHICLEMESSAGE_TYPE, 385 | ], 386 | options=None, 387 | is_extendable=False, 388 | syntax='proto3', 389 | extension_ranges=[], 390 | oneofs=[ 391 | ], 392 | serialized_start=25, 393 | serialized_end=448, 394 | ) 395 | 396 | 397 | _CANMESSAGE = _descriptor.Descriptor( 398 | name='CanMessage', 399 | full_name='openxc.CanMessage', 400 | filename=None, 401 | file=DESCRIPTOR, 402 | containing_type=None, 403 | fields=[ 404 | _descriptor.FieldDescriptor( 405 | name='bus', full_name='openxc.CanMessage.bus', index=0, 406 | number=1, type=5, cpp_type=1, label=1, 407 | has_default_value=False, default_value=0, 408 | message_type=None, enum_type=None, containing_type=None, 409 | is_extension=False, extension_scope=None, 410 | options=None), 411 | _descriptor.FieldDescriptor( 412 | name='id', full_name='openxc.CanMessage.id', index=1, 413 | number=2, type=13, cpp_type=3, label=1, 414 | has_default_value=False, default_value=0, 415 | message_type=None, enum_type=None, containing_type=None, 416 | is_extension=False, extension_scope=None, 417 | options=None), 418 | _descriptor.FieldDescriptor( 419 | name='data', full_name='openxc.CanMessage.data', index=2, 420 | number=3, type=12, cpp_type=9, label=1, 421 | has_default_value=False, default_value=_b(""), 422 | message_type=None, enum_type=None, containing_type=None, 423 | is_extension=False, extension_scope=None, 424 | options=None), 425 | _descriptor.FieldDescriptor( 426 | name='frame_format', full_name='openxc.CanMessage.frame_format', index=3, 427 | number=4, type=14, cpp_type=8, label=1, 428 | has_default_value=False, default_value=0, 429 | message_type=None, enum_type=None, containing_type=None, 430 | is_extension=False, extension_scope=None, 431 | options=None), 432 | ], 433 | extensions=[ 434 | ], 435 | nested_types=[], 436 | enum_types=[ 437 | _CANMESSAGE_FRAMEFORMAT, 438 | ], 439 | options=None, 440 | is_extendable=False, 441 | syntax='proto3', 442 | extension_ranges=[], 443 | oneofs=[ 444 | ], 445 | serialized_start=451, 446 | serialized_end=611, 447 | ) 448 | 449 | 450 | _CONTROLCOMMAND = _descriptor.Descriptor( 451 | name='ControlCommand', 452 | full_name='openxc.ControlCommand', 453 | filename=None, 454 | file=DESCRIPTOR, 455 | containing_type=None, 456 | fields=[ 457 | _descriptor.FieldDescriptor( 458 | name='type', full_name='openxc.ControlCommand.type', index=0, 459 | number=1, type=14, cpp_type=8, label=1, 460 | has_default_value=False, default_value=0, 461 | message_type=None, enum_type=None, containing_type=None, 462 | is_extension=False, extension_scope=None, 463 | options=None), 464 | _descriptor.FieldDescriptor( 465 | name='diagnostic_request', full_name='openxc.ControlCommand.diagnostic_request', index=1, 466 | number=2, type=11, cpp_type=10, label=1, 467 | has_default_value=False, default_value=None, 468 | message_type=None, enum_type=None, containing_type=None, 469 | is_extension=False, extension_scope=None, 470 | options=None), 471 | _descriptor.FieldDescriptor( 472 | name='passthrough_mode_request', full_name='openxc.ControlCommand.passthrough_mode_request', index=2, 473 | number=3, type=11, cpp_type=10, label=1, 474 | has_default_value=False, default_value=None, 475 | message_type=None, enum_type=None, containing_type=None, 476 | is_extension=False, extension_scope=None, 477 | options=None), 478 | _descriptor.FieldDescriptor( 479 | name='acceptance_filter_bypass_command', full_name='openxc.ControlCommand.acceptance_filter_bypass_command', index=3, 480 | number=4, type=11, cpp_type=10, label=1, 481 | has_default_value=False, default_value=None, 482 | message_type=None, enum_type=None, containing_type=None, 483 | is_extension=False, extension_scope=None, 484 | options=None), 485 | _descriptor.FieldDescriptor( 486 | name='payload_format_command', full_name='openxc.ControlCommand.payload_format_command', index=4, 487 | number=5, type=11, cpp_type=10, label=1, 488 | has_default_value=False, default_value=None, 489 | message_type=None, enum_type=None, containing_type=None, 490 | is_extension=False, extension_scope=None, 491 | options=None), 492 | _descriptor.FieldDescriptor( 493 | name='predefined_obd2_requests_command', full_name='openxc.ControlCommand.predefined_obd2_requests_command', index=5, 494 | number=6, type=11, cpp_type=10, label=1, 495 | has_default_value=False, default_value=None, 496 | message_type=None, enum_type=None, containing_type=None, 497 | is_extension=False, extension_scope=None, 498 | options=None), 499 | _descriptor.FieldDescriptor( 500 | name='modem_configuration_command', full_name='openxc.ControlCommand.modem_configuration_command', index=6, 501 | number=7, type=11, cpp_type=10, label=1, 502 | has_default_value=False, default_value=None, 503 | message_type=None, enum_type=None, containing_type=None, 504 | is_extension=False, extension_scope=None, 505 | options=None), 506 | _descriptor.FieldDescriptor( 507 | name='rtc_configuration_command', full_name='openxc.ControlCommand.rtc_configuration_command', index=7, 508 | number=8, type=11, cpp_type=10, label=1, 509 | has_default_value=False, default_value=None, 510 | message_type=None, enum_type=None, containing_type=None, 511 | is_extension=False, extension_scope=None, 512 | options=None), 513 | ], 514 | extensions=[ 515 | ], 516 | nested_types=[], 517 | enum_types=[ 518 | _CONTROLCOMMAND_TYPE, 519 | ], 520 | options=None, 521 | is_extendable=False, 522 | syntax='proto3', 523 | extension_ranges=[], 524 | oneofs=[ 525 | ], 526 | serialized_start=614, 527 | serialized_end=1417, 528 | ) 529 | 530 | 531 | _DIAGNOSTICCONTROLCOMMAND = _descriptor.Descriptor( 532 | name='DiagnosticControlCommand', 533 | full_name='openxc.DiagnosticControlCommand', 534 | filename=None, 535 | file=DESCRIPTOR, 536 | containing_type=None, 537 | fields=[ 538 | _descriptor.FieldDescriptor( 539 | name='request', full_name='openxc.DiagnosticControlCommand.request', index=0, 540 | number=1, type=11, cpp_type=10, label=1, 541 | has_default_value=False, default_value=None, 542 | message_type=None, enum_type=None, containing_type=None, 543 | is_extension=False, extension_scope=None, 544 | options=None), 545 | _descriptor.FieldDescriptor( 546 | name='action', full_name='openxc.DiagnosticControlCommand.action', index=1, 547 | number=2, type=14, cpp_type=8, label=1, 548 | has_default_value=False, default_value=0, 549 | message_type=None, enum_type=None, containing_type=None, 550 | is_extension=False, extension_scope=None, 551 | options=None), 552 | ], 553 | extensions=[ 554 | ], 555 | nested_types=[], 556 | enum_types=[ 557 | _DIAGNOSTICCONTROLCOMMAND_ACTION, 558 | ], 559 | options=None, 560 | is_extendable=False, 561 | syntax='proto3', 562 | extension_ranges=[], 563 | oneofs=[ 564 | ], 565 | serialized_start=1420, 566 | serialized_end=1590, 567 | ) 568 | 569 | 570 | _PASSTHROUGHMODECONTROLCOMMAND = _descriptor.Descriptor( 571 | name='PassthroughModeControlCommand', 572 | full_name='openxc.PassthroughModeControlCommand', 573 | filename=None, 574 | file=DESCRIPTOR, 575 | containing_type=None, 576 | fields=[ 577 | _descriptor.FieldDescriptor( 578 | name='bus', full_name='openxc.PassthroughModeControlCommand.bus', index=0, 579 | number=1, type=5, cpp_type=1, label=1, 580 | has_default_value=False, default_value=0, 581 | message_type=None, enum_type=None, containing_type=None, 582 | is_extension=False, extension_scope=None, 583 | options=None), 584 | _descriptor.FieldDescriptor( 585 | name='enabled', full_name='openxc.PassthroughModeControlCommand.enabled', index=1, 586 | number=2, type=8, cpp_type=7, label=1, 587 | has_default_value=False, default_value=False, 588 | message_type=None, enum_type=None, containing_type=None, 589 | is_extension=False, extension_scope=None, 590 | options=None), 591 | ], 592 | extensions=[ 593 | ], 594 | nested_types=[], 595 | enum_types=[ 596 | ], 597 | options=None, 598 | is_extendable=False, 599 | syntax='proto3', 600 | extension_ranges=[], 601 | oneofs=[ 602 | ], 603 | serialized_start=1592, 604 | serialized_end=1653, 605 | ) 606 | 607 | 608 | _ACCEPTANCEFILTERBYPASSCOMMAND = _descriptor.Descriptor( 609 | name='AcceptanceFilterBypassCommand', 610 | full_name='openxc.AcceptanceFilterBypassCommand', 611 | filename=None, 612 | file=DESCRIPTOR, 613 | containing_type=None, 614 | fields=[ 615 | _descriptor.FieldDescriptor( 616 | name='bus', full_name='openxc.AcceptanceFilterBypassCommand.bus', index=0, 617 | number=1, type=5, cpp_type=1, label=1, 618 | has_default_value=False, default_value=0, 619 | message_type=None, enum_type=None, containing_type=None, 620 | is_extension=False, extension_scope=None, 621 | options=None), 622 | _descriptor.FieldDescriptor( 623 | name='bypass', full_name='openxc.AcceptanceFilterBypassCommand.bypass', index=1, 624 | number=2, type=8, cpp_type=7, label=1, 625 | has_default_value=False, default_value=False, 626 | message_type=None, enum_type=None, containing_type=None, 627 | is_extension=False, extension_scope=None, 628 | options=None), 629 | ], 630 | extensions=[ 631 | ], 632 | nested_types=[], 633 | enum_types=[ 634 | ], 635 | options=None, 636 | is_extendable=False, 637 | syntax='proto3', 638 | extension_ranges=[], 639 | oneofs=[ 640 | ], 641 | serialized_start=1655, 642 | serialized_end=1715, 643 | ) 644 | 645 | 646 | _PAYLOADFORMATCOMMAND = _descriptor.Descriptor( 647 | name='PayloadFormatCommand', 648 | full_name='openxc.PayloadFormatCommand', 649 | filename=None, 650 | file=DESCRIPTOR, 651 | containing_type=None, 652 | fields=[ 653 | _descriptor.FieldDescriptor( 654 | name='format', full_name='openxc.PayloadFormatCommand.format', index=0, 655 | number=1, type=14, cpp_type=8, label=1, 656 | has_default_value=False, default_value=0, 657 | message_type=None, enum_type=None, containing_type=None, 658 | is_extension=False, extension_scope=None, 659 | options=None), 660 | ], 661 | extensions=[ 662 | ], 663 | nested_types=[], 664 | enum_types=[ 665 | _PAYLOADFORMATCOMMAND_PAYLOADFORMAT, 666 | ], 667 | options=None, 668 | is_extendable=False, 669 | syntax='proto3', 670 | extension_ranges=[], 671 | oneofs=[ 672 | ], 673 | serialized_start=1718, 674 | serialized_end=1870, 675 | ) 676 | 677 | 678 | _PREDEFINEDOBD2REQUESTSCOMMAND = _descriptor.Descriptor( 679 | name='PredefinedObd2RequestsCommand', 680 | full_name='openxc.PredefinedObd2RequestsCommand', 681 | filename=None, 682 | file=DESCRIPTOR, 683 | containing_type=None, 684 | fields=[ 685 | _descriptor.FieldDescriptor( 686 | name='enabled', full_name='openxc.PredefinedObd2RequestsCommand.enabled', index=0, 687 | number=1, type=8, cpp_type=7, label=1, 688 | has_default_value=False, default_value=False, 689 | message_type=None, enum_type=None, containing_type=None, 690 | is_extension=False, extension_scope=None, 691 | options=None), 692 | ], 693 | extensions=[ 694 | ], 695 | nested_types=[], 696 | enum_types=[ 697 | ], 698 | options=None, 699 | is_extendable=False, 700 | syntax='proto3', 701 | extension_ranges=[], 702 | oneofs=[ 703 | ], 704 | serialized_start=1872, 705 | serialized_end=1920, 706 | ) 707 | 708 | 709 | _NETWORKOPERATORSETTINGS_NETWORKDESCRIPTOR = _descriptor.Descriptor( 710 | name='NetworkDescriptor', 711 | full_name='openxc.NetworkOperatorSettings.NetworkDescriptor', 712 | filename=None, 713 | file=DESCRIPTOR, 714 | containing_type=None, 715 | fields=[ 716 | _descriptor.FieldDescriptor( 717 | name='PLMN', full_name='openxc.NetworkOperatorSettings.NetworkDescriptor.PLMN', index=0, 718 | number=1, type=13, cpp_type=3, label=1, 719 | has_default_value=False, default_value=0, 720 | message_type=None, enum_type=None, containing_type=None, 721 | is_extension=False, extension_scope=None, 722 | options=None), 723 | _descriptor.FieldDescriptor( 724 | name='networkType', full_name='openxc.NetworkOperatorSettings.NetworkDescriptor.networkType', index=1, 725 | number=2, type=14, cpp_type=8, label=1, 726 | has_default_value=False, default_value=0, 727 | message_type=None, enum_type=None, containing_type=None, 728 | is_extension=False, extension_scope=None, 729 | options=None), 730 | ], 731 | extensions=[ 732 | ], 733 | nested_types=[], 734 | enum_types=[ 735 | _NETWORKOPERATORSETTINGS_NETWORKDESCRIPTOR_NETWORKTYPE, 736 | ], 737 | options=None, 738 | is_extendable=False, 739 | syntax='proto3', 740 | extension_ranges=[], 741 | oneofs=[ 742 | ], 743 | serialized_start=2135, 744 | serialized_end=2287, 745 | ) 746 | 747 | _NETWORKOPERATORSETTINGS = _descriptor.Descriptor( 748 | name='NetworkOperatorSettings', 749 | full_name='openxc.NetworkOperatorSettings', 750 | filename=None, 751 | file=DESCRIPTOR, 752 | containing_type=None, 753 | fields=[ 754 | _descriptor.FieldDescriptor( 755 | name='allowDataRoaming', full_name='openxc.NetworkOperatorSettings.allowDataRoaming', index=0, 756 | number=1, type=8, cpp_type=7, label=1, 757 | has_default_value=False, default_value=False, 758 | message_type=None, enum_type=None, containing_type=None, 759 | is_extension=False, extension_scope=None, 760 | options=None), 761 | _descriptor.FieldDescriptor( 762 | name='operatorSelectMode', full_name='openxc.NetworkOperatorSettings.operatorSelectMode', index=1, 763 | number=2, type=14, cpp_type=8, label=1, 764 | has_default_value=False, default_value=0, 765 | message_type=None, enum_type=None, containing_type=None, 766 | is_extension=False, extension_scope=None, 767 | options=None), 768 | _descriptor.FieldDescriptor( 769 | name='networkDescriptor', full_name='openxc.NetworkOperatorSettings.networkDescriptor', index=2, 770 | number=3, type=11, cpp_type=10, label=1, 771 | has_default_value=False, default_value=None, 772 | message_type=None, enum_type=None, containing_type=None, 773 | is_extension=False, extension_scope=None, 774 | options=None), 775 | ], 776 | extensions=[ 777 | ], 778 | nested_types=[_NETWORKOPERATORSETTINGS_NETWORKDESCRIPTOR, ], 779 | enum_types=[ 780 | _NETWORKOPERATORSETTINGS_OPERATORSELECTMODE, 781 | ], 782 | options=None, 783 | is_extendable=False, 784 | syntax='proto3', 785 | extension_ranges=[], 786 | oneofs=[ 787 | ], 788 | serialized_start=1923, 789 | serialized_end=2388, 790 | ) 791 | 792 | 793 | _NETWORKDATASETTINGS = _descriptor.Descriptor( 794 | name='NetworkDataSettings', 795 | full_name='openxc.NetworkDataSettings', 796 | filename=None, 797 | file=DESCRIPTOR, 798 | containing_type=None, 799 | fields=[ 800 | _descriptor.FieldDescriptor( 801 | name='apn', full_name='openxc.NetworkDataSettings.apn', index=0, 802 | number=1, type=9, cpp_type=9, label=1, 803 | has_default_value=False, default_value=_b("").decode('utf-8'), 804 | message_type=None, enum_type=None, containing_type=None, 805 | is_extension=False, extension_scope=None, 806 | options=None), 807 | ], 808 | extensions=[ 809 | ], 810 | nested_types=[], 811 | enum_types=[ 812 | ], 813 | options=None, 814 | is_extendable=False, 815 | syntax='proto3', 816 | extension_ranges=[], 817 | oneofs=[ 818 | ], 819 | serialized_start=2390, 820 | serialized_end=2424, 821 | ) 822 | 823 | 824 | _SERVERCONNECTSETTINGS = _descriptor.Descriptor( 825 | name='ServerConnectSettings', 826 | full_name='openxc.ServerConnectSettings', 827 | filename=None, 828 | file=DESCRIPTOR, 829 | containing_type=None, 830 | fields=[ 831 | _descriptor.FieldDescriptor( 832 | name='host', full_name='openxc.ServerConnectSettings.host', index=0, 833 | number=1, type=9, cpp_type=9, label=1, 834 | has_default_value=False, default_value=_b("").decode('utf-8'), 835 | message_type=None, enum_type=None, containing_type=None, 836 | is_extension=False, extension_scope=None, 837 | options=None), 838 | _descriptor.FieldDescriptor( 839 | name='port', full_name='openxc.ServerConnectSettings.port', index=1, 840 | number=2, type=13, cpp_type=3, label=1, 841 | has_default_value=False, default_value=0, 842 | message_type=None, enum_type=None, containing_type=None, 843 | is_extension=False, extension_scope=None, 844 | options=None), 845 | ], 846 | extensions=[ 847 | ], 848 | nested_types=[], 849 | enum_types=[ 850 | ], 851 | options=None, 852 | is_extendable=False, 853 | syntax='proto3', 854 | extension_ranges=[], 855 | oneofs=[ 856 | ], 857 | serialized_start=2426, 858 | serialized_end=2477, 859 | ) 860 | 861 | 862 | _MODEMCONFIGURATIONCOMMAND = _descriptor.Descriptor( 863 | name='ModemConfigurationCommand', 864 | full_name='openxc.ModemConfigurationCommand', 865 | filename=None, 866 | file=DESCRIPTOR, 867 | containing_type=None, 868 | fields=[ 869 | _descriptor.FieldDescriptor( 870 | name='networkOperatorSettings', full_name='openxc.ModemConfigurationCommand.networkOperatorSettings', index=0, 871 | number=1, type=11, cpp_type=10, label=1, 872 | has_default_value=False, default_value=None, 873 | message_type=None, enum_type=None, containing_type=None, 874 | is_extension=False, extension_scope=None, 875 | options=None), 876 | _descriptor.FieldDescriptor( 877 | name='networkDataSettings', full_name='openxc.ModemConfigurationCommand.networkDataSettings', index=1, 878 | number=2, type=11, cpp_type=10, label=1, 879 | has_default_value=False, default_value=None, 880 | message_type=None, enum_type=None, containing_type=None, 881 | is_extension=False, extension_scope=None, 882 | options=None), 883 | _descriptor.FieldDescriptor( 884 | name='serverConnectSettings', full_name='openxc.ModemConfigurationCommand.serverConnectSettings', index=2, 885 | number=3, type=11, cpp_type=10, label=1, 886 | has_default_value=False, default_value=None, 887 | message_type=None, enum_type=None, containing_type=None, 888 | is_extension=False, extension_scope=None, 889 | options=None), 890 | ], 891 | extensions=[ 892 | ], 893 | nested_types=[], 894 | enum_types=[ 895 | ], 896 | options=None, 897 | is_extendable=False, 898 | syntax='proto3', 899 | extension_ranges=[], 900 | oneofs=[ 901 | ], 902 | serialized_start=2480, 903 | serialized_end=2693, 904 | ) 905 | 906 | 907 | _RTCCONFIGURATIONCOMMAND = _descriptor.Descriptor( 908 | name='RTCConfigurationCommand', 909 | full_name='openxc.RTCConfigurationCommand', 910 | filename=None, 911 | file=DESCRIPTOR, 912 | containing_type=None, 913 | fields=[ 914 | _descriptor.FieldDescriptor( 915 | name='unix_time', full_name='openxc.RTCConfigurationCommand.unix_time', index=0, 916 | number=1, type=13, cpp_type=3, label=1, 917 | has_default_value=False, default_value=0, 918 | message_type=None, enum_type=None, containing_type=None, 919 | is_extension=False, extension_scope=None, 920 | options=None), 921 | ], 922 | extensions=[ 923 | ], 924 | nested_types=[], 925 | enum_types=[ 926 | ], 927 | options=None, 928 | is_extendable=False, 929 | syntax='proto3', 930 | extension_ranges=[], 931 | oneofs=[ 932 | ], 933 | serialized_start=2695, 934 | serialized_end=2739, 935 | ) 936 | 937 | 938 | _COMMANDRESPONSE = _descriptor.Descriptor( 939 | name='CommandResponse', 940 | full_name='openxc.CommandResponse', 941 | filename=None, 942 | file=DESCRIPTOR, 943 | containing_type=None, 944 | fields=[ 945 | _descriptor.FieldDescriptor( 946 | name='type', full_name='openxc.CommandResponse.type', index=0, 947 | number=1, type=14, cpp_type=8, label=1, 948 | has_default_value=False, default_value=0, 949 | message_type=None, enum_type=None, containing_type=None, 950 | is_extension=False, extension_scope=None, 951 | options=None), 952 | _descriptor.FieldDescriptor( 953 | name='message', full_name='openxc.CommandResponse.message', index=1, 954 | number=2, type=9, cpp_type=9, label=1, 955 | has_default_value=False, default_value=_b("").decode('utf-8'), 956 | message_type=None, enum_type=None, containing_type=None, 957 | is_extension=False, extension_scope=None, 958 | options=None), 959 | _descriptor.FieldDescriptor( 960 | name='status', full_name='openxc.CommandResponse.status', index=2, 961 | number=3, type=8, cpp_type=7, label=1, 962 | has_default_value=False, default_value=False, 963 | message_type=None, enum_type=None, containing_type=None, 964 | is_extension=False, extension_scope=None, 965 | options=None), 966 | ], 967 | extensions=[ 968 | ], 969 | nested_types=[], 970 | enum_types=[ 971 | ], 972 | options=None, 973 | is_extendable=False, 974 | syntax='proto3', 975 | extension_ranges=[], 976 | oneofs=[ 977 | ], 978 | serialized_start=2741, 979 | serialized_end=2834, 980 | ) 981 | 982 | 983 | _DIAGNOSTICREQUEST = _descriptor.Descriptor( 984 | name='DiagnosticRequest', 985 | full_name='openxc.DiagnosticRequest', 986 | filename=None, 987 | file=DESCRIPTOR, 988 | containing_type=None, 989 | fields=[ 990 | _descriptor.FieldDescriptor( 991 | name='bus', full_name='openxc.DiagnosticRequest.bus', index=0, 992 | number=1, type=5, cpp_type=1, label=1, 993 | has_default_value=False, default_value=0, 994 | message_type=None, enum_type=None, containing_type=None, 995 | is_extension=False, extension_scope=None, 996 | options=None), 997 | _descriptor.FieldDescriptor( 998 | name='message_id', full_name='openxc.DiagnosticRequest.message_id', index=1, 999 | number=2, type=13, cpp_type=3, label=1, 1000 | has_default_value=False, default_value=0, 1001 | message_type=None, enum_type=None, containing_type=None, 1002 | is_extension=False, extension_scope=None, 1003 | options=None), 1004 | _descriptor.FieldDescriptor( 1005 | name='mode', full_name='openxc.DiagnosticRequest.mode', index=2, 1006 | number=3, type=13, cpp_type=3, label=1, 1007 | has_default_value=False, default_value=0, 1008 | message_type=None, enum_type=None, containing_type=None, 1009 | is_extension=False, extension_scope=None, 1010 | options=None), 1011 | _descriptor.FieldDescriptor( 1012 | name='pid', full_name='openxc.DiagnosticRequest.pid', index=3, 1013 | number=4, type=13, cpp_type=3, label=1, 1014 | has_default_value=False, default_value=0, 1015 | message_type=None, enum_type=None, containing_type=None, 1016 | is_extension=False, extension_scope=None, 1017 | options=None), 1018 | _descriptor.FieldDescriptor( 1019 | name='payload', full_name='openxc.DiagnosticRequest.payload', index=4, 1020 | number=5, type=12, cpp_type=9, label=1, 1021 | has_default_value=False, default_value=_b(""), 1022 | message_type=None, enum_type=None, containing_type=None, 1023 | is_extension=False, extension_scope=None, 1024 | options=None), 1025 | _descriptor.FieldDescriptor( 1026 | name='multiple_responses', full_name='openxc.DiagnosticRequest.multiple_responses', index=5, 1027 | number=6, type=8, cpp_type=7, label=1, 1028 | has_default_value=False, default_value=False, 1029 | message_type=None, enum_type=None, containing_type=None, 1030 | is_extension=False, extension_scope=None, 1031 | options=None), 1032 | _descriptor.FieldDescriptor( 1033 | name='frequency', full_name='openxc.DiagnosticRequest.frequency', index=6, 1034 | number=7, type=1, cpp_type=5, label=1, 1035 | has_default_value=False, default_value=float(0), 1036 | message_type=None, enum_type=None, containing_type=None, 1037 | is_extension=False, extension_scope=None, 1038 | options=None), 1039 | _descriptor.FieldDescriptor( 1040 | name='name', full_name='openxc.DiagnosticRequest.name', index=7, 1041 | number=8, type=9, cpp_type=9, label=1, 1042 | has_default_value=False, default_value=_b("").decode('utf-8'), 1043 | message_type=None, enum_type=None, containing_type=None, 1044 | is_extension=False, extension_scope=None, 1045 | options=None), 1046 | _descriptor.FieldDescriptor( 1047 | name='decoded_type', full_name='openxc.DiagnosticRequest.decoded_type', index=8, 1048 | number=9, type=14, cpp_type=8, label=1, 1049 | has_default_value=False, default_value=0, 1050 | message_type=None, enum_type=None, containing_type=None, 1051 | is_extension=False, extension_scope=None, 1052 | options=None), 1053 | ], 1054 | extensions=[ 1055 | ], 1056 | nested_types=[], 1057 | enum_types=[ 1058 | _DIAGNOSTICREQUEST_DECODEDTYPE, 1059 | ], 1060 | options=None, 1061 | is_extendable=False, 1062 | syntax='proto3', 1063 | extension_ranges=[], 1064 | oneofs=[ 1065 | ], 1066 | serialized_start=2837, 1067 | serialized_end=3102, 1068 | ) 1069 | 1070 | 1071 | _DIAGNOSTICRESPONSE = _descriptor.Descriptor( 1072 | name='DiagnosticResponse', 1073 | full_name='openxc.DiagnosticResponse', 1074 | filename=None, 1075 | file=DESCRIPTOR, 1076 | containing_type=None, 1077 | fields=[ 1078 | _descriptor.FieldDescriptor( 1079 | name='bus', full_name='openxc.DiagnosticResponse.bus', index=0, 1080 | number=1, type=5, cpp_type=1, label=1, 1081 | has_default_value=False, default_value=0, 1082 | message_type=None, enum_type=None, containing_type=None, 1083 | is_extension=False, extension_scope=None, 1084 | options=None), 1085 | _descriptor.FieldDescriptor( 1086 | name='message_id', full_name='openxc.DiagnosticResponse.message_id', index=1, 1087 | number=2, type=13, cpp_type=3, label=1, 1088 | has_default_value=False, default_value=0, 1089 | message_type=None, enum_type=None, containing_type=None, 1090 | is_extension=False, extension_scope=None, 1091 | options=None), 1092 | _descriptor.FieldDescriptor( 1093 | name='mode', full_name='openxc.DiagnosticResponse.mode', index=2, 1094 | number=3, type=13, cpp_type=3, label=1, 1095 | has_default_value=False, default_value=0, 1096 | message_type=None, enum_type=None, containing_type=None, 1097 | is_extension=False, extension_scope=None, 1098 | options=None), 1099 | _descriptor.FieldDescriptor( 1100 | name='pid', full_name='openxc.DiagnosticResponse.pid', index=3, 1101 | number=4, type=13, cpp_type=3, label=1, 1102 | has_default_value=False, default_value=0, 1103 | message_type=None, enum_type=None, containing_type=None, 1104 | is_extension=False, extension_scope=None, 1105 | options=None), 1106 | _descriptor.FieldDescriptor( 1107 | name='success', full_name='openxc.DiagnosticResponse.success', index=4, 1108 | number=5, type=8, cpp_type=7, label=1, 1109 | has_default_value=False, default_value=False, 1110 | message_type=None, enum_type=None, containing_type=None, 1111 | is_extension=False, extension_scope=None, 1112 | options=None), 1113 | _descriptor.FieldDescriptor( 1114 | name='negative_response_code', full_name='openxc.DiagnosticResponse.negative_response_code', index=5, 1115 | number=6, type=13, cpp_type=3, label=1, 1116 | has_default_value=False, default_value=0, 1117 | message_type=None, enum_type=None, containing_type=None, 1118 | is_extension=False, extension_scope=None, 1119 | options=None), 1120 | _descriptor.FieldDescriptor( 1121 | name='payload', full_name='openxc.DiagnosticResponse.payload', index=6, 1122 | number=7, type=12, cpp_type=9, label=1, 1123 | has_default_value=False, default_value=_b(""), 1124 | message_type=None, enum_type=None, containing_type=None, 1125 | is_extension=False, extension_scope=None, 1126 | options=None), 1127 | _descriptor.FieldDescriptor( 1128 | name='value', full_name='openxc.DiagnosticResponse.value', index=7, 1129 | number=8, type=11, cpp_type=10, label=1, 1130 | has_default_value=False, default_value=None, 1131 | message_type=None, enum_type=None, containing_type=None, 1132 | is_extension=False, extension_scope=None, 1133 | options=None), 1134 | ], 1135 | extensions=[ 1136 | ], 1137 | nested_types=[], 1138 | enum_types=[ 1139 | ], 1140 | options=None, 1141 | is_extendable=False, 1142 | syntax='proto3', 1143 | extension_ranges=[], 1144 | oneofs=[ 1145 | ], 1146 | serialized_start=3105, 1147 | serialized_end=3288, 1148 | ) 1149 | 1150 | 1151 | _DYNAMICFIELD = _descriptor.Descriptor( 1152 | name='DynamicField', 1153 | full_name='openxc.DynamicField', 1154 | filename=None, 1155 | file=DESCRIPTOR, 1156 | containing_type=None, 1157 | fields=[ 1158 | _descriptor.FieldDescriptor( 1159 | name='type', full_name='openxc.DynamicField.type', index=0, 1160 | number=1, type=14, cpp_type=8, label=1, 1161 | has_default_value=False, default_value=0, 1162 | message_type=None, enum_type=None, containing_type=None, 1163 | is_extension=False, extension_scope=None, 1164 | options=None), 1165 | _descriptor.FieldDescriptor( 1166 | name='string_value', full_name='openxc.DynamicField.string_value', index=1, 1167 | number=2, type=9, cpp_type=9, label=1, 1168 | has_default_value=False, default_value=_b("").decode('utf-8'), 1169 | message_type=None, enum_type=None, containing_type=None, 1170 | is_extension=False, extension_scope=None, 1171 | options=None), 1172 | _descriptor.FieldDescriptor( 1173 | name='numeric_value', full_name='openxc.DynamicField.numeric_value', index=2, 1174 | number=3, type=1, cpp_type=5, label=1, 1175 | has_default_value=False, default_value=float(0), 1176 | message_type=None, enum_type=None, containing_type=None, 1177 | is_extension=False, extension_scope=None, 1178 | options=None), 1179 | _descriptor.FieldDescriptor( 1180 | name='boolean_value', full_name='openxc.DynamicField.boolean_value', index=3, 1181 | number=4, type=8, cpp_type=7, label=1, 1182 | has_default_value=False, default_value=False, 1183 | message_type=None, enum_type=None, containing_type=None, 1184 | is_extension=False, extension_scope=None, 1185 | options=None), 1186 | ], 1187 | extensions=[ 1188 | ], 1189 | nested_types=[], 1190 | enum_types=[ 1191 | _DYNAMICFIELD_TYPE, 1192 | ], 1193 | options=None, 1194 | is_extendable=False, 1195 | syntax='proto3', 1196 | extension_ranges=[], 1197 | oneofs=[ 1198 | ], 1199 | serialized_start=3291, 1200 | serialized_end=3465, 1201 | ) 1202 | 1203 | 1204 | _SIMPLEMESSAGE = _descriptor.Descriptor( 1205 | name='SimpleMessage', 1206 | full_name='openxc.SimpleMessage', 1207 | filename=None, 1208 | file=DESCRIPTOR, 1209 | containing_type=None, 1210 | fields=[ 1211 | _descriptor.FieldDescriptor( 1212 | name='name', full_name='openxc.SimpleMessage.name', index=0, 1213 | number=1, type=9, cpp_type=9, label=1, 1214 | has_default_value=False, default_value=_b("").decode('utf-8'), 1215 | message_type=None, enum_type=None, containing_type=None, 1216 | is_extension=False, extension_scope=None, 1217 | options=None), 1218 | _descriptor.FieldDescriptor( 1219 | name='value', full_name='openxc.SimpleMessage.value', index=1, 1220 | number=2, type=11, cpp_type=10, label=1, 1221 | has_default_value=False, default_value=None, 1222 | message_type=None, enum_type=None, containing_type=None, 1223 | is_extension=False, extension_scope=None, 1224 | options=None), 1225 | _descriptor.FieldDescriptor( 1226 | name='event', full_name='openxc.SimpleMessage.event', index=2, 1227 | number=3, type=11, cpp_type=10, label=1, 1228 | has_default_value=False, default_value=None, 1229 | message_type=None, enum_type=None, containing_type=None, 1230 | is_extension=False, extension_scope=None, 1231 | options=None), 1232 | ], 1233 | extensions=[ 1234 | ], 1235 | nested_types=[], 1236 | enum_types=[ 1237 | ], 1238 | options=None, 1239 | is_extendable=False, 1240 | syntax='proto3', 1241 | extension_ranges=[], 1242 | oneofs=[ 1243 | ], 1244 | serialized_start=3467, 1245 | serialized_end=3570, 1246 | ) 1247 | 1248 | _VEHICLEMESSAGE.fields_by_name['type'].enum_type = _VEHICLEMESSAGE_TYPE 1249 | _VEHICLEMESSAGE.fields_by_name['can_message'].message_type = _CANMESSAGE 1250 | _VEHICLEMESSAGE.fields_by_name['simple_message'].message_type = _SIMPLEMESSAGE 1251 | _VEHICLEMESSAGE.fields_by_name['diagnostic_response'].message_type = _DIAGNOSTICRESPONSE 1252 | _VEHICLEMESSAGE.fields_by_name['control_command'].message_type = _CONTROLCOMMAND 1253 | _VEHICLEMESSAGE.fields_by_name['command_response'].message_type = _COMMANDRESPONSE 1254 | _VEHICLEMESSAGE_TYPE.containing_type = _VEHICLEMESSAGE 1255 | _CANMESSAGE.fields_by_name['frame_format'].enum_type = _CANMESSAGE_FRAMEFORMAT 1256 | _CANMESSAGE_FRAMEFORMAT.containing_type = _CANMESSAGE 1257 | _CONTROLCOMMAND.fields_by_name['type'].enum_type = _CONTROLCOMMAND_TYPE 1258 | _CONTROLCOMMAND.fields_by_name['diagnostic_request'].message_type = _DIAGNOSTICCONTROLCOMMAND 1259 | _CONTROLCOMMAND.fields_by_name['passthrough_mode_request'].message_type = _PASSTHROUGHMODECONTROLCOMMAND 1260 | _CONTROLCOMMAND.fields_by_name['acceptance_filter_bypass_command'].message_type = _ACCEPTANCEFILTERBYPASSCOMMAND 1261 | _CONTROLCOMMAND.fields_by_name['payload_format_command'].message_type = _PAYLOADFORMATCOMMAND 1262 | _CONTROLCOMMAND.fields_by_name['predefined_obd2_requests_command'].message_type = _PREDEFINEDOBD2REQUESTSCOMMAND 1263 | _CONTROLCOMMAND.fields_by_name['modem_configuration_command'].message_type = _MODEMCONFIGURATIONCOMMAND 1264 | _CONTROLCOMMAND.fields_by_name['rtc_configuration_command'].message_type = _RTCCONFIGURATIONCOMMAND 1265 | _CONTROLCOMMAND_TYPE.containing_type = _CONTROLCOMMAND 1266 | _DIAGNOSTICCONTROLCOMMAND.fields_by_name['request'].message_type = _DIAGNOSTICREQUEST 1267 | _DIAGNOSTICCONTROLCOMMAND.fields_by_name['action'].enum_type = _DIAGNOSTICCONTROLCOMMAND_ACTION 1268 | _DIAGNOSTICCONTROLCOMMAND_ACTION.containing_type = _DIAGNOSTICCONTROLCOMMAND 1269 | _PAYLOADFORMATCOMMAND.fields_by_name['format'].enum_type = _PAYLOADFORMATCOMMAND_PAYLOADFORMAT 1270 | _PAYLOADFORMATCOMMAND_PAYLOADFORMAT.containing_type = _PAYLOADFORMATCOMMAND 1271 | _NETWORKOPERATORSETTINGS_NETWORKDESCRIPTOR.fields_by_name['networkType'].enum_type = _NETWORKOPERATORSETTINGS_NETWORKDESCRIPTOR_NETWORKTYPE 1272 | _NETWORKOPERATORSETTINGS_NETWORKDESCRIPTOR.containing_type = _NETWORKOPERATORSETTINGS 1273 | _NETWORKOPERATORSETTINGS_NETWORKDESCRIPTOR_NETWORKTYPE.containing_type = _NETWORKOPERATORSETTINGS_NETWORKDESCRIPTOR 1274 | _NETWORKOPERATORSETTINGS.fields_by_name['operatorSelectMode'].enum_type = _NETWORKOPERATORSETTINGS_OPERATORSELECTMODE 1275 | _NETWORKOPERATORSETTINGS.fields_by_name['networkDescriptor'].message_type = _NETWORKOPERATORSETTINGS_NETWORKDESCRIPTOR 1276 | _NETWORKOPERATORSETTINGS_OPERATORSELECTMODE.containing_type = _NETWORKOPERATORSETTINGS 1277 | _MODEMCONFIGURATIONCOMMAND.fields_by_name['networkOperatorSettings'].message_type = _NETWORKOPERATORSETTINGS 1278 | _MODEMCONFIGURATIONCOMMAND.fields_by_name['networkDataSettings'].message_type = _NETWORKDATASETTINGS 1279 | _MODEMCONFIGURATIONCOMMAND.fields_by_name['serverConnectSettings'].message_type = _SERVERCONNECTSETTINGS 1280 | _COMMANDRESPONSE.fields_by_name['type'].enum_type = _CONTROLCOMMAND_TYPE 1281 | _DIAGNOSTICREQUEST.fields_by_name['decoded_type'].enum_type = _DIAGNOSTICREQUEST_DECODEDTYPE 1282 | _DIAGNOSTICREQUEST_DECODEDTYPE.containing_type = _DIAGNOSTICREQUEST 1283 | _DIAGNOSTICRESPONSE.fields_by_name['value'].message_type = _DYNAMICFIELD 1284 | _DYNAMICFIELD.fields_by_name['type'].enum_type = _DYNAMICFIELD_TYPE 1285 | _DYNAMICFIELD_TYPE.containing_type = _DYNAMICFIELD 1286 | _SIMPLEMESSAGE.fields_by_name['value'].message_type = _DYNAMICFIELD 1287 | _SIMPLEMESSAGE.fields_by_name['event'].message_type = _DYNAMICFIELD 1288 | DESCRIPTOR.message_types_by_name['VehicleMessage'] = _VEHICLEMESSAGE 1289 | DESCRIPTOR.message_types_by_name['CanMessage'] = _CANMESSAGE 1290 | DESCRIPTOR.message_types_by_name['ControlCommand'] = _CONTROLCOMMAND 1291 | DESCRIPTOR.message_types_by_name['DiagnosticControlCommand'] = _DIAGNOSTICCONTROLCOMMAND 1292 | DESCRIPTOR.message_types_by_name['PassthroughModeControlCommand'] = _PASSTHROUGHMODECONTROLCOMMAND 1293 | DESCRIPTOR.message_types_by_name['AcceptanceFilterBypassCommand'] = _ACCEPTANCEFILTERBYPASSCOMMAND 1294 | DESCRIPTOR.message_types_by_name['PayloadFormatCommand'] = _PAYLOADFORMATCOMMAND 1295 | DESCRIPTOR.message_types_by_name['PredefinedObd2RequestsCommand'] = _PREDEFINEDOBD2REQUESTSCOMMAND 1296 | DESCRIPTOR.message_types_by_name['NetworkOperatorSettings'] = _NETWORKOPERATORSETTINGS 1297 | DESCRIPTOR.message_types_by_name['NetworkDataSettings'] = _NETWORKDATASETTINGS 1298 | DESCRIPTOR.message_types_by_name['ServerConnectSettings'] = _SERVERCONNECTSETTINGS 1299 | DESCRIPTOR.message_types_by_name['ModemConfigurationCommand'] = _MODEMCONFIGURATIONCOMMAND 1300 | DESCRIPTOR.message_types_by_name['RTCConfigurationCommand'] = _RTCCONFIGURATIONCOMMAND 1301 | DESCRIPTOR.message_types_by_name['CommandResponse'] = _COMMANDRESPONSE 1302 | DESCRIPTOR.message_types_by_name['DiagnosticRequest'] = _DIAGNOSTICREQUEST 1303 | DESCRIPTOR.message_types_by_name['DiagnosticResponse'] = _DIAGNOSTICRESPONSE 1304 | DESCRIPTOR.message_types_by_name['DynamicField'] = _DYNAMICFIELD 1305 | DESCRIPTOR.message_types_by_name['SimpleMessage'] = _SIMPLEMESSAGE 1306 | 1307 | VehicleMessage = _reflection.GeneratedProtocolMessageType('VehicleMessage', (_message.Message,), dict( 1308 | DESCRIPTOR = _VEHICLEMESSAGE, 1309 | __module__ = 'openxc_pb2' 1310 | # @@protoc_insertion_point(class_scope:openxc.VehicleMessage) 1311 | )) 1312 | _sym_db.RegisterMessage(VehicleMessage) 1313 | 1314 | CanMessage = _reflection.GeneratedProtocolMessageType('CanMessage', (_message.Message,), dict( 1315 | DESCRIPTOR = _CANMESSAGE, 1316 | __module__ = 'openxc_pb2' 1317 | # @@protoc_insertion_point(class_scope:openxc.CanMessage) 1318 | )) 1319 | _sym_db.RegisterMessage(CanMessage) 1320 | 1321 | ControlCommand = _reflection.GeneratedProtocolMessageType('ControlCommand', (_message.Message,), dict( 1322 | DESCRIPTOR = _CONTROLCOMMAND, 1323 | __module__ = 'openxc_pb2' 1324 | # @@protoc_insertion_point(class_scope:openxc.ControlCommand) 1325 | )) 1326 | _sym_db.RegisterMessage(ControlCommand) 1327 | 1328 | DiagnosticControlCommand = _reflection.GeneratedProtocolMessageType('DiagnosticControlCommand', (_message.Message,), dict( 1329 | DESCRIPTOR = _DIAGNOSTICCONTROLCOMMAND, 1330 | __module__ = 'openxc_pb2' 1331 | # @@protoc_insertion_point(class_scope:openxc.DiagnosticControlCommand) 1332 | )) 1333 | _sym_db.RegisterMessage(DiagnosticControlCommand) 1334 | 1335 | PassthroughModeControlCommand = _reflection.GeneratedProtocolMessageType('PassthroughModeControlCommand', (_message.Message,), dict( 1336 | DESCRIPTOR = _PASSTHROUGHMODECONTROLCOMMAND, 1337 | __module__ = 'openxc_pb2' 1338 | # @@protoc_insertion_point(class_scope:openxc.PassthroughModeControlCommand) 1339 | )) 1340 | _sym_db.RegisterMessage(PassthroughModeControlCommand) 1341 | 1342 | AcceptanceFilterBypassCommand = _reflection.GeneratedProtocolMessageType('AcceptanceFilterBypassCommand', (_message.Message,), dict( 1343 | DESCRIPTOR = _ACCEPTANCEFILTERBYPASSCOMMAND, 1344 | __module__ = 'openxc_pb2' 1345 | # @@protoc_insertion_point(class_scope:openxc.AcceptanceFilterBypassCommand) 1346 | )) 1347 | _sym_db.RegisterMessage(AcceptanceFilterBypassCommand) 1348 | 1349 | PayloadFormatCommand = _reflection.GeneratedProtocolMessageType('PayloadFormatCommand', (_message.Message,), dict( 1350 | DESCRIPTOR = _PAYLOADFORMATCOMMAND, 1351 | __module__ = 'openxc_pb2' 1352 | # @@protoc_insertion_point(class_scope:openxc.PayloadFormatCommand) 1353 | )) 1354 | _sym_db.RegisterMessage(PayloadFormatCommand) 1355 | 1356 | PredefinedObd2RequestsCommand = _reflection.GeneratedProtocolMessageType('PredefinedObd2RequestsCommand', (_message.Message,), dict( 1357 | DESCRIPTOR = _PREDEFINEDOBD2REQUESTSCOMMAND, 1358 | __module__ = 'openxc_pb2' 1359 | # @@protoc_insertion_point(class_scope:openxc.PredefinedObd2RequestsCommand) 1360 | )) 1361 | _sym_db.RegisterMessage(PredefinedObd2RequestsCommand) 1362 | 1363 | NetworkOperatorSettings = _reflection.GeneratedProtocolMessageType('NetworkOperatorSettings', (_message.Message,), dict( 1364 | 1365 | NetworkDescriptor = _reflection.GeneratedProtocolMessageType('NetworkDescriptor', (_message.Message,), dict( 1366 | DESCRIPTOR = _NETWORKOPERATORSETTINGS_NETWORKDESCRIPTOR, 1367 | __module__ = 'openxc_pb2' 1368 | # @@protoc_insertion_point(class_scope:openxc.NetworkOperatorSettings.NetworkDescriptor) 1369 | )) 1370 | , 1371 | DESCRIPTOR = _NETWORKOPERATORSETTINGS, 1372 | __module__ = 'openxc_pb2' 1373 | # @@protoc_insertion_point(class_scope:openxc.NetworkOperatorSettings) 1374 | )) 1375 | _sym_db.RegisterMessage(NetworkOperatorSettings) 1376 | _sym_db.RegisterMessage(NetworkOperatorSettings.NetworkDescriptor) 1377 | 1378 | NetworkDataSettings = _reflection.GeneratedProtocolMessageType('NetworkDataSettings', (_message.Message,), dict( 1379 | DESCRIPTOR = _NETWORKDATASETTINGS, 1380 | __module__ = 'openxc_pb2' 1381 | # @@protoc_insertion_point(class_scope:openxc.NetworkDataSettings) 1382 | )) 1383 | _sym_db.RegisterMessage(NetworkDataSettings) 1384 | 1385 | ServerConnectSettings = _reflection.GeneratedProtocolMessageType('ServerConnectSettings', (_message.Message,), dict( 1386 | DESCRIPTOR = _SERVERCONNECTSETTINGS, 1387 | __module__ = 'openxc_pb2' 1388 | # @@protoc_insertion_point(class_scope:openxc.ServerConnectSettings) 1389 | )) 1390 | _sym_db.RegisterMessage(ServerConnectSettings) 1391 | 1392 | ModemConfigurationCommand = _reflection.GeneratedProtocolMessageType('ModemConfigurationCommand', (_message.Message,), dict( 1393 | DESCRIPTOR = _MODEMCONFIGURATIONCOMMAND, 1394 | __module__ = 'openxc_pb2' 1395 | # @@protoc_insertion_point(class_scope:openxc.ModemConfigurationCommand) 1396 | )) 1397 | _sym_db.RegisterMessage(ModemConfigurationCommand) 1398 | 1399 | RTCConfigurationCommand = _reflection.GeneratedProtocolMessageType('RTCConfigurationCommand', (_message.Message,), dict( 1400 | DESCRIPTOR = _RTCCONFIGURATIONCOMMAND, 1401 | __module__ = 'openxc_pb2' 1402 | # @@protoc_insertion_point(class_scope:openxc.RTCConfigurationCommand) 1403 | )) 1404 | _sym_db.RegisterMessage(RTCConfigurationCommand) 1405 | 1406 | CommandResponse = _reflection.GeneratedProtocolMessageType('CommandResponse', (_message.Message,), dict( 1407 | DESCRIPTOR = _COMMANDRESPONSE, 1408 | __module__ = 'openxc_pb2' 1409 | # @@protoc_insertion_point(class_scope:openxc.CommandResponse) 1410 | )) 1411 | _sym_db.RegisterMessage(CommandResponse) 1412 | 1413 | DiagnosticRequest = _reflection.GeneratedProtocolMessageType('DiagnosticRequest', (_message.Message,), dict( 1414 | DESCRIPTOR = _DIAGNOSTICREQUEST, 1415 | __module__ = 'openxc_pb2' 1416 | # @@protoc_insertion_point(class_scope:openxc.DiagnosticRequest) 1417 | )) 1418 | _sym_db.RegisterMessage(DiagnosticRequest) 1419 | 1420 | DiagnosticResponse = _reflection.GeneratedProtocolMessageType('DiagnosticResponse', (_message.Message,), dict( 1421 | DESCRIPTOR = _DIAGNOSTICRESPONSE, 1422 | __module__ = 'openxc_pb2' 1423 | # @@protoc_insertion_point(class_scope:openxc.DiagnosticResponse) 1424 | )) 1425 | _sym_db.RegisterMessage(DiagnosticResponse) 1426 | 1427 | DynamicField = _reflection.GeneratedProtocolMessageType('DynamicField', (_message.Message,), dict( 1428 | DESCRIPTOR = _DYNAMICFIELD, 1429 | __module__ = 'openxc_pb2' 1430 | # @@protoc_insertion_point(class_scope:openxc.DynamicField) 1431 | )) 1432 | _sym_db.RegisterMessage(DynamicField) 1433 | 1434 | SimpleMessage = _reflection.GeneratedProtocolMessageType('SimpleMessage', (_message.Message,), dict( 1435 | DESCRIPTOR = _SIMPLEMESSAGE, 1436 | __module__ = 'openxc_pb2' 1437 | # @@protoc_insertion_point(class_scope:openxc.SimpleMessage) 1438 | )) 1439 | _sym_db.RegisterMessage(SimpleMessage) 1440 | 1441 | 1442 | DESCRIPTOR.has_options = True 1443 | DESCRIPTOR._options = _descriptor._ParseOptions(descriptor_pb2.FileOptions(), _b('\n\ncom.openxcB\016BinaryMessages')) 1444 | # @@protoc_insertion_point(module_scope) 1445 | -------------------------------------------------------------------------------- /gen/go/openxc.pb.go: -------------------------------------------------------------------------------- 1 | // Code generated by protoc-gen-go. DO NOT EDIT. 2 | // source: openxc.proto 3 | 4 | package openxc 5 | 6 | import ( 7 | fmt "fmt" 8 | proto "github.com/golang/protobuf/proto" 9 | math "math" 10 | ) 11 | 12 | // Reference imports to suppress errors if they are not otherwise used. 13 | var _ = proto.Marshal 14 | var _ = fmt.Errorf 15 | var _ = math.Inf 16 | 17 | // This is a compile-time assertion to ensure that this generated file 18 | // is compatible with the proto package it is being compiled against. 19 | // A compilation error at this line likely means your copy of the 20 | // proto package needs to be updated. 21 | const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package 22 | 23 | type VehicleMessage_Type int32 24 | 25 | const ( 26 | VehicleMessage_CAN VehicleMessage_Type = 1 27 | VehicleMessage_SIMPLE VehicleMessage_Type = 2 28 | VehicleMessage_DIAGNOSTIC VehicleMessage_Type = 3 29 | VehicleMessage_CONTROL_COMMAND VehicleMessage_Type = 4 30 | VehicleMessage_COMMAND_RESPONSE VehicleMessage_Type = 5 31 | ) 32 | 33 | var VehicleMessage_Type_name = map[int32]string{ 34 | 1: "CAN", 35 | 2: "SIMPLE", 36 | 3: "DIAGNOSTIC", 37 | 4: "CONTROL_COMMAND", 38 | 5: "COMMAND_RESPONSE", 39 | } 40 | 41 | var VehicleMessage_Type_value = map[string]int32{ 42 | "CAN": 1, 43 | "SIMPLE": 2, 44 | "DIAGNOSTIC": 3, 45 | "CONTROL_COMMAND": 4, 46 | "COMMAND_RESPONSE": 5, 47 | } 48 | 49 | func (x VehicleMessage_Type) Enum() *VehicleMessage_Type { 50 | p := new(VehicleMessage_Type) 51 | *p = x 52 | return p 53 | } 54 | 55 | func (x VehicleMessage_Type) String() string { 56 | return proto.EnumName(VehicleMessage_Type_name, int32(x)) 57 | } 58 | 59 | func (x *VehicleMessage_Type) UnmarshalJSON(data []byte) error { 60 | value, err := proto.UnmarshalJSONEnum(VehicleMessage_Type_value, data, "VehicleMessage_Type") 61 | if err != nil { 62 | return err 63 | } 64 | *x = VehicleMessage_Type(value) 65 | return nil 66 | } 67 | 68 | func (VehicleMessage_Type) EnumDescriptor() ([]byte, []int) { 69 | return fileDescriptor_df5aea3535dd3286, []int{0, 0} 70 | } 71 | 72 | type CanMessage_FrameFormat int32 73 | 74 | const ( 75 | CanMessage_STANDARD CanMessage_FrameFormat = 1 76 | CanMessage_EXTENDED CanMessage_FrameFormat = 2 77 | ) 78 | 79 | var CanMessage_FrameFormat_name = map[int32]string{ 80 | 1: "STANDARD", 81 | 2: "EXTENDED", 82 | } 83 | 84 | var CanMessage_FrameFormat_value = map[string]int32{ 85 | "STANDARD": 1, 86 | "EXTENDED": 2, 87 | } 88 | 89 | func (x CanMessage_FrameFormat) Enum() *CanMessage_FrameFormat { 90 | p := new(CanMessage_FrameFormat) 91 | *p = x 92 | return p 93 | } 94 | 95 | func (x CanMessage_FrameFormat) String() string { 96 | return proto.EnumName(CanMessage_FrameFormat_name, int32(x)) 97 | } 98 | 99 | func (x *CanMessage_FrameFormat) UnmarshalJSON(data []byte) error { 100 | value, err := proto.UnmarshalJSONEnum(CanMessage_FrameFormat_value, data, "CanMessage_FrameFormat") 101 | if err != nil { 102 | return err 103 | } 104 | *x = CanMessage_FrameFormat(value) 105 | return nil 106 | } 107 | 108 | func (CanMessage_FrameFormat) EnumDescriptor() ([]byte, []int) { 109 | return fileDescriptor_df5aea3535dd3286, []int{1, 0} 110 | } 111 | 112 | type ControlCommand_Type int32 113 | 114 | const ( 115 | ControlCommand_VERSION ControlCommand_Type = 1 116 | ControlCommand_DEVICE_ID ControlCommand_Type = 2 117 | ControlCommand_DIAGNOSTIC ControlCommand_Type = 3 118 | ControlCommand_PASSTHROUGH ControlCommand_Type = 4 119 | ControlCommand_ACCEPTANCE_FILTER_BYPASS ControlCommand_Type = 5 120 | ControlCommand_PAYLOAD_FORMAT ControlCommand_Type = 6 121 | ControlCommand_PREDEFINED_OBD2_REQUESTS ControlCommand_Type = 7 122 | ControlCommand_MODEM_CONFIGURATION ControlCommand_Type = 8 123 | ControlCommand_RTC_CONFIGURATION ControlCommand_Type = 9 124 | ControlCommand_SD_MOUNT_STATUS ControlCommand_Type = 10 125 | ControlCommand_PLATFORM ControlCommand_Type = 11 126 | ) 127 | 128 | var ControlCommand_Type_name = map[int32]string{ 129 | 1: "VERSION", 130 | 2: "DEVICE_ID", 131 | 3: "DIAGNOSTIC", 132 | 4: "PASSTHROUGH", 133 | 5: "ACCEPTANCE_FILTER_BYPASS", 134 | 6: "PAYLOAD_FORMAT", 135 | 7: "PREDEFINED_OBD2_REQUESTS", 136 | 8: "MODEM_CONFIGURATION", 137 | 9: "RTC_CONFIGURATION", 138 | 10: "SD_MOUNT_STATUS", 139 | 11: "PLATFORM", 140 | } 141 | 142 | var ControlCommand_Type_value = map[string]int32{ 143 | "VERSION": 1, 144 | "DEVICE_ID": 2, 145 | "DIAGNOSTIC": 3, 146 | "PASSTHROUGH": 4, 147 | "ACCEPTANCE_FILTER_BYPASS": 5, 148 | "PAYLOAD_FORMAT": 6, 149 | "PREDEFINED_OBD2_REQUESTS": 7, 150 | "MODEM_CONFIGURATION": 8, 151 | "RTC_CONFIGURATION": 9, 152 | "SD_MOUNT_STATUS": 10, 153 | "PLATFORM": 11, 154 | } 155 | 156 | func (x ControlCommand_Type) Enum() *ControlCommand_Type { 157 | p := new(ControlCommand_Type) 158 | *p = x 159 | return p 160 | } 161 | 162 | func (x ControlCommand_Type) String() string { 163 | return proto.EnumName(ControlCommand_Type_name, int32(x)) 164 | } 165 | 166 | func (x *ControlCommand_Type) UnmarshalJSON(data []byte) error { 167 | value, err := proto.UnmarshalJSONEnum(ControlCommand_Type_value, data, "ControlCommand_Type") 168 | if err != nil { 169 | return err 170 | } 171 | *x = ControlCommand_Type(value) 172 | return nil 173 | } 174 | 175 | func (ControlCommand_Type) EnumDescriptor() ([]byte, []int) { 176 | return fileDescriptor_df5aea3535dd3286, []int{2, 0} 177 | } 178 | 179 | type DiagnosticControlCommand_Action int32 180 | 181 | const ( 182 | DiagnosticControlCommand_ADD DiagnosticControlCommand_Action = 1 183 | DiagnosticControlCommand_CANCEL DiagnosticControlCommand_Action = 2 184 | ) 185 | 186 | var DiagnosticControlCommand_Action_name = map[int32]string{ 187 | 1: "ADD", 188 | 2: "CANCEL", 189 | } 190 | 191 | var DiagnosticControlCommand_Action_value = map[string]int32{ 192 | "ADD": 1, 193 | "CANCEL": 2, 194 | } 195 | 196 | func (x DiagnosticControlCommand_Action) Enum() *DiagnosticControlCommand_Action { 197 | p := new(DiagnosticControlCommand_Action) 198 | *p = x 199 | return p 200 | } 201 | 202 | func (x DiagnosticControlCommand_Action) String() string { 203 | return proto.EnumName(DiagnosticControlCommand_Action_name, int32(x)) 204 | } 205 | 206 | func (x *DiagnosticControlCommand_Action) UnmarshalJSON(data []byte) error { 207 | value, err := proto.UnmarshalJSONEnum(DiagnosticControlCommand_Action_value, data, "DiagnosticControlCommand_Action") 208 | if err != nil { 209 | return err 210 | } 211 | *x = DiagnosticControlCommand_Action(value) 212 | return nil 213 | } 214 | 215 | func (DiagnosticControlCommand_Action) EnumDescriptor() ([]byte, []int) { 216 | return fileDescriptor_df5aea3535dd3286, []int{3, 0} 217 | } 218 | 219 | type PayloadFormatCommand_PayloadFormat int32 220 | 221 | const ( 222 | PayloadFormatCommand_JSON PayloadFormatCommand_PayloadFormat = 1 223 | PayloadFormatCommand_PROTOBUF PayloadFormatCommand_PayloadFormat = 2 224 | ) 225 | 226 | var PayloadFormatCommand_PayloadFormat_name = map[int32]string{ 227 | 1: "JSON", 228 | 2: "PROTOBUF", 229 | } 230 | 231 | var PayloadFormatCommand_PayloadFormat_value = map[string]int32{ 232 | "JSON": 1, 233 | "PROTOBUF": 2, 234 | } 235 | 236 | func (x PayloadFormatCommand_PayloadFormat) Enum() *PayloadFormatCommand_PayloadFormat { 237 | p := new(PayloadFormatCommand_PayloadFormat) 238 | *p = x 239 | return p 240 | } 241 | 242 | func (x PayloadFormatCommand_PayloadFormat) String() string { 243 | return proto.EnumName(PayloadFormatCommand_PayloadFormat_name, int32(x)) 244 | } 245 | 246 | func (x *PayloadFormatCommand_PayloadFormat) UnmarshalJSON(data []byte) error { 247 | value, err := proto.UnmarshalJSONEnum(PayloadFormatCommand_PayloadFormat_value, data, "PayloadFormatCommand_PayloadFormat") 248 | if err != nil { 249 | return err 250 | } 251 | *x = PayloadFormatCommand_PayloadFormat(value) 252 | return nil 253 | } 254 | 255 | func (PayloadFormatCommand_PayloadFormat) EnumDescriptor() ([]byte, []int) { 256 | return fileDescriptor_df5aea3535dd3286, []int{6, 0} 257 | } 258 | 259 | type NetworkOperatorSettings_OperatorSelectMode int32 260 | 261 | const ( 262 | NetworkOperatorSettings_AUTOMATIC NetworkOperatorSettings_OperatorSelectMode = 0 263 | NetworkOperatorSettings_MANUAL NetworkOperatorSettings_OperatorSelectMode = 1 264 | NetworkOperatorSettings_DEREGISTER NetworkOperatorSettings_OperatorSelectMode = 2 265 | NetworkOperatorSettings_SET_ONLY NetworkOperatorSettings_OperatorSelectMode = 3 266 | NetworkOperatorSettings_MANUAL_AUTOMATIC NetworkOperatorSettings_OperatorSelectMode = 4 267 | ) 268 | 269 | var NetworkOperatorSettings_OperatorSelectMode_name = map[int32]string{ 270 | 0: "AUTOMATIC", 271 | 1: "MANUAL", 272 | 2: "DEREGISTER", 273 | 3: "SET_ONLY", 274 | 4: "MANUAL_AUTOMATIC", 275 | } 276 | 277 | var NetworkOperatorSettings_OperatorSelectMode_value = map[string]int32{ 278 | "AUTOMATIC": 0, 279 | "MANUAL": 1, 280 | "DEREGISTER": 2, 281 | "SET_ONLY": 3, 282 | "MANUAL_AUTOMATIC": 4, 283 | } 284 | 285 | func (x NetworkOperatorSettings_OperatorSelectMode) Enum() *NetworkOperatorSettings_OperatorSelectMode { 286 | p := new(NetworkOperatorSettings_OperatorSelectMode) 287 | *p = x 288 | return p 289 | } 290 | 291 | func (x NetworkOperatorSettings_OperatorSelectMode) String() string { 292 | return proto.EnumName(NetworkOperatorSettings_OperatorSelectMode_name, int32(x)) 293 | } 294 | 295 | func (x *NetworkOperatorSettings_OperatorSelectMode) UnmarshalJSON(data []byte) error { 296 | value, err := proto.UnmarshalJSONEnum(NetworkOperatorSettings_OperatorSelectMode_value, data, "NetworkOperatorSettings_OperatorSelectMode") 297 | if err != nil { 298 | return err 299 | } 300 | *x = NetworkOperatorSettings_OperatorSelectMode(value) 301 | return nil 302 | } 303 | 304 | func (NetworkOperatorSettings_OperatorSelectMode) EnumDescriptor() ([]byte, []int) { 305 | return fileDescriptor_df5aea3535dd3286, []int{8, 0} 306 | } 307 | 308 | type NetworkOperatorSettings_NetworkDescriptor_NetworkType int32 309 | 310 | const ( 311 | NetworkOperatorSettings_NetworkDescriptor_GSM NetworkOperatorSettings_NetworkDescriptor_NetworkType = 0 312 | NetworkOperatorSettings_NetworkDescriptor_UTRAN NetworkOperatorSettings_NetworkDescriptor_NetworkType = 2 313 | ) 314 | 315 | var NetworkOperatorSettings_NetworkDescriptor_NetworkType_name = map[int32]string{ 316 | 0: "GSM", 317 | 2: "UTRAN", 318 | } 319 | 320 | var NetworkOperatorSettings_NetworkDescriptor_NetworkType_value = map[string]int32{ 321 | "GSM": 0, 322 | "UTRAN": 2, 323 | } 324 | 325 | func (x NetworkOperatorSettings_NetworkDescriptor_NetworkType) Enum() *NetworkOperatorSettings_NetworkDescriptor_NetworkType { 326 | p := new(NetworkOperatorSettings_NetworkDescriptor_NetworkType) 327 | *p = x 328 | return p 329 | } 330 | 331 | func (x NetworkOperatorSettings_NetworkDescriptor_NetworkType) String() string { 332 | return proto.EnumName(NetworkOperatorSettings_NetworkDescriptor_NetworkType_name, int32(x)) 333 | } 334 | 335 | func (x *NetworkOperatorSettings_NetworkDescriptor_NetworkType) UnmarshalJSON(data []byte) error { 336 | value, err := proto.UnmarshalJSONEnum(NetworkOperatorSettings_NetworkDescriptor_NetworkType_value, data, "NetworkOperatorSettings_NetworkDescriptor_NetworkType") 337 | if err != nil { 338 | return err 339 | } 340 | *x = NetworkOperatorSettings_NetworkDescriptor_NetworkType(value) 341 | return nil 342 | } 343 | 344 | func (NetworkOperatorSettings_NetworkDescriptor_NetworkType) EnumDescriptor() ([]byte, []int) { 345 | return fileDescriptor_df5aea3535dd3286, []int{8, 0, 0} 346 | } 347 | 348 | type DiagnosticRequest_DecodedType int32 349 | 350 | const ( 351 | DiagnosticRequest_NONE DiagnosticRequest_DecodedType = 1 352 | DiagnosticRequest_OBD2 DiagnosticRequest_DecodedType = 2 353 | ) 354 | 355 | var DiagnosticRequest_DecodedType_name = map[int32]string{ 356 | 1: "NONE", 357 | 2: "OBD2", 358 | } 359 | 360 | var DiagnosticRequest_DecodedType_value = map[string]int32{ 361 | "NONE": 1, 362 | "OBD2": 2, 363 | } 364 | 365 | func (x DiagnosticRequest_DecodedType) Enum() *DiagnosticRequest_DecodedType { 366 | p := new(DiagnosticRequest_DecodedType) 367 | *p = x 368 | return p 369 | } 370 | 371 | func (x DiagnosticRequest_DecodedType) String() string { 372 | return proto.EnumName(DiagnosticRequest_DecodedType_name, int32(x)) 373 | } 374 | 375 | func (x *DiagnosticRequest_DecodedType) UnmarshalJSON(data []byte) error { 376 | value, err := proto.UnmarshalJSONEnum(DiagnosticRequest_DecodedType_value, data, "DiagnosticRequest_DecodedType") 377 | if err != nil { 378 | return err 379 | } 380 | *x = DiagnosticRequest_DecodedType(value) 381 | return nil 382 | } 383 | 384 | func (DiagnosticRequest_DecodedType) EnumDescriptor() ([]byte, []int) { 385 | return fileDescriptor_df5aea3535dd3286, []int{14, 0} 386 | } 387 | 388 | type DynamicField_Type int32 389 | 390 | const ( 391 | DynamicField_STRING DynamicField_Type = 1 392 | DynamicField_NUM DynamicField_Type = 2 393 | DynamicField_BOOL DynamicField_Type = 3 394 | ) 395 | 396 | var DynamicField_Type_name = map[int32]string{ 397 | 1: "STRING", 398 | 2: "NUM", 399 | 3: "BOOL", 400 | } 401 | 402 | var DynamicField_Type_value = map[string]int32{ 403 | "STRING": 1, 404 | "NUM": 2, 405 | "BOOL": 3, 406 | } 407 | 408 | func (x DynamicField_Type) Enum() *DynamicField_Type { 409 | p := new(DynamicField_Type) 410 | *p = x 411 | return p 412 | } 413 | 414 | func (x DynamicField_Type) String() string { 415 | return proto.EnumName(DynamicField_Type_name, int32(x)) 416 | } 417 | 418 | func (x *DynamicField_Type) UnmarshalJSON(data []byte) error { 419 | value, err := proto.UnmarshalJSONEnum(DynamicField_Type_value, data, "DynamicField_Type") 420 | if err != nil { 421 | return err 422 | } 423 | *x = DynamicField_Type(value) 424 | return nil 425 | } 426 | 427 | func (DynamicField_Type) EnumDescriptor() ([]byte, []int) { 428 | return fileDescriptor_df5aea3535dd3286, []int{16, 0} 429 | } 430 | 431 | type VehicleMessage struct { 432 | Type *VehicleMessage_Type `protobuf:"varint,1,opt,name=type,enum=openxc.VehicleMessage_Type" json:"type,omitempty"` 433 | CanMessage *CanMessage `protobuf:"bytes,2,opt,name=can_message,json=canMessage" json:"can_message,omitempty"` 434 | SimpleMessage *SimpleMessage `protobuf:"bytes,3,opt,name=simple_message,json=simpleMessage" json:"simple_message,omitempty"` 435 | DiagnosticResponse *DiagnosticResponse `protobuf:"bytes,4,opt,name=diagnostic_response,json=diagnosticResponse" json:"diagnostic_response,omitempty"` 436 | ControlCommand *ControlCommand `protobuf:"bytes,5,opt,name=control_command,json=controlCommand" json:"control_command,omitempty"` 437 | CommandResponse *CommandResponse `protobuf:"bytes,6,opt,name=command_response,json=commandResponse" json:"command_response,omitempty"` 438 | Timestamp *uint64 `protobuf:"varint,7,opt,name=timestamp" json:"timestamp,omitempty"` 439 | XXX_NoUnkeyedLiteral struct{} `json:"-"` 440 | XXX_unrecognized []byte `json:"-"` 441 | XXX_sizecache int32 `json:"-"` 442 | } 443 | 444 | func (m *VehicleMessage) Reset() { *m = VehicleMessage{} } 445 | func (m *VehicleMessage) String() string { return proto.CompactTextString(m) } 446 | func (*VehicleMessage) ProtoMessage() {} 447 | func (*VehicleMessage) Descriptor() ([]byte, []int) { 448 | return fileDescriptor_df5aea3535dd3286, []int{0} 449 | } 450 | 451 | func (m *VehicleMessage) XXX_Unmarshal(b []byte) error { 452 | return xxx_messageInfo_VehicleMessage.Unmarshal(m, b) 453 | } 454 | func (m *VehicleMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 455 | return xxx_messageInfo_VehicleMessage.Marshal(b, m, deterministic) 456 | } 457 | func (m *VehicleMessage) XXX_Merge(src proto.Message) { 458 | xxx_messageInfo_VehicleMessage.Merge(m, src) 459 | } 460 | func (m *VehicleMessage) XXX_Size() int { 461 | return xxx_messageInfo_VehicleMessage.Size(m) 462 | } 463 | func (m *VehicleMessage) XXX_DiscardUnknown() { 464 | xxx_messageInfo_VehicleMessage.DiscardUnknown(m) 465 | } 466 | 467 | var xxx_messageInfo_VehicleMessage proto.InternalMessageInfo 468 | 469 | func (m *VehicleMessage) GetType() VehicleMessage_Type { 470 | if m != nil && m.Type != nil { 471 | return *m.Type 472 | } 473 | return VehicleMessage_CAN 474 | } 475 | 476 | func (m *VehicleMessage) GetCanMessage() *CanMessage { 477 | if m != nil { 478 | return m.CanMessage 479 | } 480 | return nil 481 | } 482 | 483 | func (m *VehicleMessage) GetSimpleMessage() *SimpleMessage { 484 | if m != nil { 485 | return m.SimpleMessage 486 | } 487 | return nil 488 | } 489 | 490 | func (m *VehicleMessage) GetDiagnosticResponse() *DiagnosticResponse { 491 | if m != nil { 492 | return m.DiagnosticResponse 493 | } 494 | return nil 495 | } 496 | 497 | func (m *VehicleMessage) GetControlCommand() *ControlCommand { 498 | if m != nil { 499 | return m.ControlCommand 500 | } 501 | return nil 502 | } 503 | 504 | func (m *VehicleMessage) GetCommandResponse() *CommandResponse { 505 | if m != nil { 506 | return m.CommandResponse 507 | } 508 | return nil 509 | } 510 | 511 | func (m *VehicleMessage) GetTimestamp() uint64 { 512 | if m != nil && m.Timestamp != nil { 513 | return *m.Timestamp 514 | } 515 | return 0 516 | } 517 | 518 | type CanMessage struct { 519 | Bus *int32 `protobuf:"varint,1,opt,name=bus" json:"bus,omitempty"` 520 | Id *uint32 `protobuf:"varint,2,opt,name=id" json:"id,omitempty"` 521 | Data []byte `protobuf:"bytes,3,opt,name=data" json:"data,omitempty"` 522 | FrameFormat *CanMessage_FrameFormat `protobuf:"varint,4,opt,name=frame_format,json=frameFormat,enum=openxc.CanMessage_FrameFormat" json:"frame_format,omitempty"` 523 | XXX_NoUnkeyedLiteral struct{} `json:"-"` 524 | XXX_unrecognized []byte `json:"-"` 525 | XXX_sizecache int32 `json:"-"` 526 | } 527 | 528 | func (m *CanMessage) Reset() { *m = CanMessage{} } 529 | func (m *CanMessage) String() string { return proto.CompactTextString(m) } 530 | func (*CanMessage) ProtoMessage() {} 531 | func (*CanMessage) Descriptor() ([]byte, []int) { 532 | return fileDescriptor_df5aea3535dd3286, []int{1} 533 | } 534 | 535 | func (m *CanMessage) XXX_Unmarshal(b []byte) error { 536 | return xxx_messageInfo_CanMessage.Unmarshal(m, b) 537 | } 538 | func (m *CanMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 539 | return xxx_messageInfo_CanMessage.Marshal(b, m, deterministic) 540 | } 541 | func (m *CanMessage) XXX_Merge(src proto.Message) { 542 | xxx_messageInfo_CanMessage.Merge(m, src) 543 | } 544 | func (m *CanMessage) XXX_Size() int { 545 | return xxx_messageInfo_CanMessage.Size(m) 546 | } 547 | func (m *CanMessage) XXX_DiscardUnknown() { 548 | xxx_messageInfo_CanMessage.DiscardUnknown(m) 549 | } 550 | 551 | var xxx_messageInfo_CanMessage proto.InternalMessageInfo 552 | 553 | func (m *CanMessage) GetBus() int32 { 554 | if m != nil && m.Bus != nil { 555 | return *m.Bus 556 | } 557 | return 0 558 | } 559 | 560 | func (m *CanMessage) GetId() uint32 { 561 | if m != nil && m.Id != nil { 562 | return *m.Id 563 | } 564 | return 0 565 | } 566 | 567 | func (m *CanMessage) GetData() []byte { 568 | if m != nil { 569 | return m.Data 570 | } 571 | return nil 572 | } 573 | 574 | func (m *CanMessage) GetFrameFormat() CanMessage_FrameFormat { 575 | if m != nil && m.FrameFormat != nil { 576 | return *m.FrameFormat 577 | } 578 | return CanMessage_STANDARD 579 | } 580 | 581 | type ControlCommand struct { 582 | Type *ControlCommand_Type `protobuf:"varint,1,opt,name=type,enum=openxc.ControlCommand_Type" json:"type,omitempty"` 583 | DiagnosticRequest *DiagnosticControlCommand `protobuf:"bytes,2,opt,name=diagnostic_request,json=diagnosticRequest" json:"diagnostic_request,omitempty"` 584 | PassthroughModeRequest *PassthroughModeControlCommand `protobuf:"bytes,3,opt,name=passthrough_mode_request,json=passthroughModeRequest" json:"passthrough_mode_request,omitempty"` 585 | AcceptanceFilterBypassCommand *AcceptanceFilterBypassCommand `protobuf:"bytes,4,opt,name=acceptance_filter_bypass_command,json=acceptanceFilterBypassCommand" json:"acceptance_filter_bypass_command,omitempty"` 586 | PayloadFormatCommand *PayloadFormatCommand `protobuf:"bytes,5,opt,name=payload_format_command,json=payloadFormatCommand" json:"payload_format_command,omitempty"` 587 | PredefinedObd2RequestsCommand *PredefinedObd2RequestsCommand `protobuf:"bytes,6,opt,name=predefined_obd2_requests_command,json=predefinedObd2RequestsCommand" json:"predefined_obd2_requests_command,omitempty"` 588 | ModemConfigurationCommand *ModemConfigurationCommand `protobuf:"bytes,7,opt,name=modem_configuration_command,json=modemConfigurationCommand" json:"modem_configuration_command,omitempty"` 589 | RtcConfigurationCommand *RTCConfigurationCommand `protobuf:"bytes,8,opt,name=rtc_configuration_command,json=rtcConfigurationCommand" json:"rtc_configuration_command,omitempty"` 590 | XXX_NoUnkeyedLiteral struct{} `json:"-"` 591 | XXX_unrecognized []byte `json:"-"` 592 | XXX_sizecache int32 `json:"-"` 593 | } 594 | 595 | func (m *ControlCommand) Reset() { *m = ControlCommand{} } 596 | func (m *ControlCommand) String() string { return proto.CompactTextString(m) } 597 | func (*ControlCommand) ProtoMessage() {} 598 | func (*ControlCommand) Descriptor() ([]byte, []int) { 599 | return fileDescriptor_df5aea3535dd3286, []int{2} 600 | } 601 | 602 | func (m *ControlCommand) XXX_Unmarshal(b []byte) error { 603 | return xxx_messageInfo_ControlCommand.Unmarshal(m, b) 604 | } 605 | func (m *ControlCommand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 606 | return xxx_messageInfo_ControlCommand.Marshal(b, m, deterministic) 607 | } 608 | func (m *ControlCommand) XXX_Merge(src proto.Message) { 609 | xxx_messageInfo_ControlCommand.Merge(m, src) 610 | } 611 | func (m *ControlCommand) XXX_Size() int { 612 | return xxx_messageInfo_ControlCommand.Size(m) 613 | } 614 | func (m *ControlCommand) XXX_DiscardUnknown() { 615 | xxx_messageInfo_ControlCommand.DiscardUnknown(m) 616 | } 617 | 618 | var xxx_messageInfo_ControlCommand proto.InternalMessageInfo 619 | 620 | func (m *ControlCommand) GetType() ControlCommand_Type { 621 | if m != nil && m.Type != nil { 622 | return *m.Type 623 | } 624 | return ControlCommand_VERSION 625 | } 626 | 627 | func (m *ControlCommand) GetDiagnosticRequest() *DiagnosticControlCommand { 628 | if m != nil { 629 | return m.DiagnosticRequest 630 | } 631 | return nil 632 | } 633 | 634 | func (m *ControlCommand) GetPassthroughModeRequest() *PassthroughModeControlCommand { 635 | if m != nil { 636 | return m.PassthroughModeRequest 637 | } 638 | return nil 639 | } 640 | 641 | func (m *ControlCommand) GetAcceptanceFilterBypassCommand() *AcceptanceFilterBypassCommand { 642 | if m != nil { 643 | return m.AcceptanceFilterBypassCommand 644 | } 645 | return nil 646 | } 647 | 648 | func (m *ControlCommand) GetPayloadFormatCommand() *PayloadFormatCommand { 649 | if m != nil { 650 | return m.PayloadFormatCommand 651 | } 652 | return nil 653 | } 654 | 655 | func (m *ControlCommand) GetPredefinedObd2RequestsCommand() *PredefinedObd2RequestsCommand { 656 | if m != nil { 657 | return m.PredefinedObd2RequestsCommand 658 | } 659 | return nil 660 | } 661 | 662 | func (m *ControlCommand) GetModemConfigurationCommand() *ModemConfigurationCommand { 663 | if m != nil { 664 | return m.ModemConfigurationCommand 665 | } 666 | return nil 667 | } 668 | 669 | func (m *ControlCommand) GetRtcConfigurationCommand() *RTCConfigurationCommand { 670 | if m != nil { 671 | return m.RtcConfigurationCommand 672 | } 673 | return nil 674 | } 675 | 676 | type DiagnosticControlCommand struct { 677 | Request *DiagnosticRequest `protobuf:"bytes,1,opt,name=request" json:"request,omitempty"` 678 | Action *DiagnosticControlCommand_Action `protobuf:"varint,2,opt,name=action,enum=openxc.DiagnosticControlCommand_Action" json:"action,omitempty"` 679 | XXX_NoUnkeyedLiteral struct{} `json:"-"` 680 | XXX_unrecognized []byte `json:"-"` 681 | XXX_sizecache int32 `json:"-"` 682 | } 683 | 684 | func (m *DiagnosticControlCommand) Reset() { *m = DiagnosticControlCommand{} } 685 | func (m *DiagnosticControlCommand) String() string { return proto.CompactTextString(m) } 686 | func (*DiagnosticControlCommand) ProtoMessage() {} 687 | func (*DiagnosticControlCommand) Descriptor() ([]byte, []int) { 688 | return fileDescriptor_df5aea3535dd3286, []int{3} 689 | } 690 | 691 | func (m *DiagnosticControlCommand) XXX_Unmarshal(b []byte) error { 692 | return xxx_messageInfo_DiagnosticControlCommand.Unmarshal(m, b) 693 | } 694 | func (m *DiagnosticControlCommand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 695 | return xxx_messageInfo_DiagnosticControlCommand.Marshal(b, m, deterministic) 696 | } 697 | func (m *DiagnosticControlCommand) XXX_Merge(src proto.Message) { 698 | xxx_messageInfo_DiagnosticControlCommand.Merge(m, src) 699 | } 700 | func (m *DiagnosticControlCommand) XXX_Size() int { 701 | return xxx_messageInfo_DiagnosticControlCommand.Size(m) 702 | } 703 | func (m *DiagnosticControlCommand) XXX_DiscardUnknown() { 704 | xxx_messageInfo_DiagnosticControlCommand.DiscardUnknown(m) 705 | } 706 | 707 | var xxx_messageInfo_DiagnosticControlCommand proto.InternalMessageInfo 708 | 709 | func (m *DiagnosticControlCommand) GetRequest() *DiagnosticRequest { 710 | if m != nil { 711 | return m.Request 712 | } 713 | return nil 714 | } 715 | 716 | func (m *DiagnosticControlCommand) GetAction() DiagnosticControlCommand_Action { 717 | if m != nil && m.Action != nil { 718 | return *m.Action 719 | } 720 | return DiagnosticControlCommand_ADD 721 | } 722 | 723 | type PassthroughModeControlCommand struct { 724 | Bus *int32 `protobuf:"varint,1,opt,name=bus" json:"bus,omitempty"` 725 | Enabled *bool `protobuf:"varint,2,opt,name=enabled" json:"enabled,omitempty"` 726 | XXX_NoUnkeyedLiteral struct{} `json:"-"` 727 | XXX_unrecognized []byte `json:"-"` 728 | XXX_sizecache int32 `json:"-"` 729 | } 730 | 731 | func (m *PassthroughModeControlCommand) Reset() { *m = PassthroughModeControlCommand{} } 732 | func (m *PassthroughModeControlCommand) String() string { return proto.CompactTextString(m) } 733 | func (*PassthroughModeControlCommand) ProtoMessage() {} 734 | func (*PassthroughModeControlCommand) Descriptor() ([]byte, []int) { 735 | return fileDescriptor_df5aea3535dd3286, []int{4} 736 | } 737 | 738 | func (m *PassthroughModeControlCommand) XXX_Unmarshal(b []byte) error { 739 | return xxx_messageInfo_PassthroughModeControlCommand.Unmarshal(m, b) 740 | } 741 | func (m *PassthroughModeControlCommand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 742 | return xxx_messageInfo_PassthroughModeControlCommand.Marshal(b, m, deterministic) 743 | } 744 | func (m *PassthroughModeControlCommand) XXX_Merge(src proto.Message) { 745 | xxx_messageInfo_PassthroughModeControlCommand.Merge(m, src) 746 | } 747 | func (m *PassthroughModeControlCommand) XXX_Size() int { 748 | return xxx_messageInfo_PassthroughModeControlCommand.Size(m) 749 | } 750 | func (m *PassthroughModeControlCommand) XXX_DiscardUnknown() { 751 | xxx_messageInfo_PassthroughModeControlCommand.DiscardUnknown(m) 752 | } 753 | 754 | var xxx_messageInfo_PassthroughModeControlCommand proto.InternalMessageInfo 755 | 756 | func (m *PassthroughModeControlCommand) GetBus() int32 { 757 | if m != nil && m.Bus != nil { 758 | return *m.Bus 759 | } 760 | return 0 761 | } 762 | 763 | func (m *PassthroughModeControlCommand) GetEnabled() bool { 764 | if m != nil && m.Enabled != nil { 765 | return *m.Enabled 766 | } 767 | return false 768 | } 769 | 770 | type AcceptanceFilterBypassCommand struct { 771 | Bus *int32 `protobuf:"varint,1,opt,name=bus" json:"bus,omitempty"` 772 | Bypass *bool `protobuf:"varint,2,opt,name=bypass" json:"bypass,omitempty"` 773 | XXX_NoUnkeyedLiteral struct{} `json:"-"` 774 | XXX_unrecognized []byte `json:"-"` 775 | XXX_sizecache int32 `json:"-"` 776 | } 777 | 778 | func (m *AcceptanceFilterBypassCommand) Reset() { *m = AcceptanceFilterBypassCommand{} } 779 | func (m *AcceptanceFilterBypassCommand) String() string { return proto.CompactTextString(m) } 780 | func (*AcceptanceFilterBypassCommand) ProtoMessage() {} 781 | func (*AcceptanceFilterBypassCommand) Descriptor() ([]byte, []int) { 782 | return fileDescriptor_df5aea3535dd3286, []int{5} 783 | } 784 | 785 | func (m *AcceptanceFilterBypassCommand) XXX_Unmarshal(b []byte) error { 786 | return xxx_messageInfo_AcceptanceFilterBypassCommand.Unmarshal(m, b) 787 | } 788 | func (m *AcceptanceFilterBypassCommand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 789 | return xxx_messageInfo_AcceptanceFilterBypassCommand.Marshal(b, m, deterministic) 790 | } 791 | func (m *AcceptanceFilterBypassCommand) XXX_Merge(src proto.Message) { 792 | xxx_messageInfo_AcceptanceFilterBypassCommand.Merge(m, src) 793 | } 794 | func (m *AcceptanceFilterBypassCommand) XXX_Size() int { 795 | return xxx_messageInfo_AcceptanceFilterBypassCommand.Size(m) 796 | } 797 | func (m *AcceptanceFilterBypassCommand) XXX_DiscardUnknown() { 798 | xxx_messageInfo_AcceptanceFilterBypassCommand.DiscardUnknown(m) 799 | } 800 | 801 | var xxx_messageInfo_AcceptanceFilterBypassCommand proto.InternalMessageInfo 802 | 803 | func (m *AcceptanceFilterBypassCommand) GetBus() int32 { 804 | if m != nil && m.Bus != nil { 805 | return *m.Bus 806 | } 807 | return 0 808 | } 809 | 810 | func (m *AcceptanceFilterBypassCommand) GetBypass() bool { 811 | if m != nil && m.Bypass != nil { 812 | return *m.Bypass 813 | } 814 | return false 815 | } 816 | 817 | type PayloadFormatCommand struct { 818 | Format *PayloadFormatCommand_PayloadFormat `protobuf:"varint,1,opt,name=format,enum=openxc.PayloadFormatCommand_PayloadFormat" json:"format,omitempty"` 819 | XXX_NoUnkeyedLiteral struct{} `json:"-"` 820 | XXX_unrecognized []byte `json:"-"` 821 | XXX_sizecache int32 `json:"-"` 822 | } 823 | 824 | func (m *PayloadFormatCommand) Reset() { *m = PayloadFormatCommand{} } 825 | func (m *PayloadFormatCommand) String() string { return proto.CompactTextString(m) } 826 | func (*PayloadFormatCommand) ProtoMessage() {} 827 | func (*PayloadFormatCommand) Descriptor() ([]byte, []int) { 828 | return fileDescriptor_df5aea3535dd3286, []int{6} 829 | } 830 | 831 | func (m *PayloadFormatCommand) XXX_Unmarshal(b []byte) error { 832 | return xxx_messageInfo_PayloadFormatCommand.Unmarshal(m, b) 833 | } 834 | func (m *PayloadFormatCommand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 835 | return xxx_messageInfo_PayloadFormatCommand.Marshal(b, m, deterministic) 836 | } 837 | func (m *PayloadFormatCommand) XXX_Merge(src proto.Message) { 838 | xxx_messageInfo_PayloadFormatCommand.Merge(m, src) 839 | } 840 | func (m *PayloadFormatCommand) XXX_Size() int { 841 | return xxx_messageInfo_PayloadFormatCommand.Size(m) 842 | } 843 | func (m *PayloadFormatCommand) XXX_DiscardUnknown() { 844 | xxx_messageInfo_PayloadFormatCommand.DiscardUnknown(m) 845 | } 846 | 847 | var xxx_messageInfo_PayloadFormatCommand proto.InternalMessageInfo 848 | 849 | func (m *PayloadFormatCommand) GetFormat() PayloadFormatCommand_PayloadFormat { 850 | if m != nil && m.Format != nil { 851 | return *m.Format 852 | } 853 | return PayloadFormatCommand_JSON 854 | } 855 | 856 | type PredefinedObd2RequestsCommand struct { 857 | Enabled *bool `protobuf:"varint,1,opt,name=enabled" json:"enabled,omitempty"` 858 | XXX_NoUnkeyedLiteral struct{} `json:"-"` 859 | XXX_unrecognized []byte `json:"-"` 860 | XXX_sizecache int32 `json:"-"` 861 | } 862 | 863 | func (m *PredefinedObd2RequestsCommand) Reset() { *m = PredefinedObd2RequestsCommand{} } 864 | func (m *PredefinedObd2RequestsCommand) String() string { return proto.CompactTextString(m) } 865 | func (*PredefinedObd2RequestsCommand) ProtoMessage() {} 866 | func (*PredefinedObd2RequestsCommand) Descriptor() ([]byte, []int) { 867 | return fileDescriptor_df5aea3535dd3286, []int{7} 868 | } 869 | 870 | func (m *PredefinedObd2RequestsCommand) XXX_Unmarshal(b []byte) error { 871 | return xxx_messageInfo_PredefinedObd2RequestsCommand.Unmarshal(m, b) 872 | } 873 | func (m *PredefinedObd2RequestsCommand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 874 | return xxx_messageInfo_PredefinedObd2RequestsCommand.Marshal(b, m, deterministic) 875 | } 876 | func (m *PredefinedObd2RequestsCommand) XXX_Merge(src proto.Message) { 877 | xxx_messageInfo_PredefinedObd2RequestsCommand.Merge(m, src) 878 | } 879 | func (m *PredefinedObd2RequestsCommand) XXX_Size() int { 880 | return xxx_messageInfo_PredefinedObd2RequestsCommand.Size(m) 881 | } 882 | func (m *PredefinedObd2RequestsCommand) XXX_DiscardUnknown() { 883 | xxx_messageInfo_PredefinedObd2RequestsCommand.DiscardUnknown(m) 884 | } 885 | 886 | var xxx_messageInfo_PredefinedObd2RequestsCommand proto.InternalMessageInfo 887 | 888 | func (m *PredefinedObd2RequestsCommand) GetEnabled() bool { 889 | if m != nil && m.Enabled != nil { 890 | return *m.Enabled 891 | } 892 | return false 893 | } 894 | 895 | type NetworkOperatorSettings struct { 896 | AllowDataRoaming *bool `protobuf:"varint,1,opt,name=allowDataRoaming" json:"allowDataRoaming,omitempty"` 897 | OperatorSelectMode *NetworkOperatorSettings_OperatorSelectMode `protobuf:"varint,2,opt,name=operatorSelectMode,enum=openxc.NetworkOperatorSettings_OperatorSelectMode" json:"operatorSelectMode,omitempty"` 898 | NetworkDescriptor *NetworkOperatorSettings_NetworkDescriptor `protobuf:"bytes,3,opt,name=networkDescriptor" json:"networkDescriptor,omitempty"` 899 | XXX_NoUnkeyedLiteral struct{} `json:"-"` 900 | XXX_unrecognized []byte `json:"-"` 901 | XXX_sizecache int32 `json:"-"` 902 | } 903 | 904 | func (m *NetworkOperatorSettings) Reset() { *m = NetworkOperatorSettings{} } 905 | func (m *NetworkOperatorSettings) String() string { return proto.CompactTextString(m) } 906 | func (*NetworkOperatorSettings) ProtoMessage() {} 907 | func (*NetworkOperatorSettings) Descriptor() ([]byte, []int) { 908 | return fileDescriptor_df5aea3535dd3286, []int{8} 909 | } 910 | 911 | func (m *NetworkOperatorSettings) XXX_Unmarshal(b []byte) error { 912 | return xxx_messageInfo_NetworkOperatorSettings.Unmarshal(m, b) 913 | } 914 | func (m *NetworkOperatorSettings) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 915 | return xxx_messageInfo_NetworkOperatorSettings.Marshal(b, m, deterministic) 916 | } 917 | func (m *NetworkOperatorSettings) XXX_Merge(src proto.Message) { 918 | xxx_messageInfo_NetworkOperatorSettings.Merge(m, src) 919 | } 920 | func (m *NetworkOperatorSettings) XXX_Size() int { 921 | return xxx_messageInfo_NetworkOperatorSettings.Size(m) 922 | } 923 | func (m *NetworkOperatorSettings) XXX_DiscardUnknown() { 924 | xxx_messageInfo_NetworkOperatorSettings.DiscardUnknown(m) 925 | } 926 | 927 | var xxx_messageInfo_NetworkOperatorSettings proto.InternalMessageInfo 928 | 929 | func (m *NetworkOperatorSettings) GetAllowDataRoaming() bool { 930 | if m != nil && m.AllowDataRoaming != nil { 931 | return *m.AllowDataRoaming 932 | } 933 | return false 934 | } 935 | 936 | func (m *NetworkOperatorSettings) GetOperatorSelectMode() NetworkOperatorSettings_OperatorSelectMode { 937 | if m != nil && m.OperatorSelectMode != nil { 938 | return *m.OperatorSelectMode 939 | } 940 | return NetworkOperatorSettings_AUTOMATIC 941 | } 942 | 943 | func (m *NetworkOperatorSettings) GetNetworkDescriptor() *NetworkOperatorSettings_NetworkDescriptor { 944 | if m != nil { 945 | return m.NetworkDescriptor 946 | } 947 | return nil 948 | } 949 | 950 | type NetworkOperatorSettings_NetworkDescriptor struct { 951 | PLMN *uint32 `protobuf:"varint,1,opt,name=PLMN" json:"PLMN,omitempty"` 952 | NetworkType *NetworkOperatorSettings_NetworkDescriptor_NetworkType `protobuf:"varint,2,opt,name=networkType,enum=openxc.NetworkOperatorSettings_NetworkDescriptor_NetworkType" json:"networkType,omitempty"` 953 | XXX_NoUnkeyedLiteral struct{} `json:"-"` 954 | XXX_unrecognized []byte `json:"-"` 955 | XXX_sizecache int32 `json:"-"` 956 | } 957 | 958 | func (m *NetworkOperatorSettings_NetworkDescriptor) Reset() { 959 | *m = NetworkOperatorSettings_NetworkDescriptor{} 960 | } 961 | func (m *NetworkOperatorSettings_NetworkDescriptor) String() string { return proto.CompactTextString(m) } 962 | func (*NetworkOperatorSettings_NetworkDescriptor) ProtoMessage() {} 963 | func (*NetworkOperatorSettings_NetworkDescriptor) Descriptor() ([]byte, []int) { 964 | return fileDescriptor_df5aea3535dd3286, []int{8, 0} 965 | } 966 | 967 | func (m *NetworkOperatorSettings_NetworkDescriptor) XXX_Unmarshal(b []byte) error { 968 | return xxx_messageInfo_NetworkOperatorSettings_NetworkDescriptor.Unmarshal(m, b) 969 | } 970 | func (m *NetworkOperatorSettings_NetworkDescriptor) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 971 | return xxx_messageInfo_NetworkOperatorSettings_NetworkDescriptor.Marshal(b, m, deterministic) 972 | } 973 | func (m *NetworkOperatorSettings_NetworkDescriptor) XXX_Merge(src proto.Message) { 974 | xxx_messageInfo_NetworkOperatorSettings_NetworkDescriptor.Merge(m, src) 975 | } 976 | func (m *NetworkOperatorSettings_NetworkDescriptor) XXX_Size() int { 977 | return xxx_messageInfo_NetworkOperatorSettings_NetworkDescriptor.Size(m) 978 | } 979 | func (m *NetworkOperatorSettings_NetworkDescriptor) XXX_DiscardUnknown() { 980 | xxx_messageInfo_NetworkOperatorSettings_NetworkDescriptor.DiscardUnknown(m) 981 | } 982 | 983 | var xxx_messageInfo_NetworkOperatorSettings_NetworkDescriptor proto.InternalMessageInfo 984 | 985 | func (m *NetworkOperatorSettings_NetworkDescriptor) GetPLMN() uint32 { 986 | if m != nil && m.PLMN != nil { 987 | return *m.PLMN 988 | } 989 | return 0 990 | } 991 | 992 | func (m *NetworkOperatorSettings_NetworkDescriptor) GetNetworkType() NetworkOperatorSettings_NetworkDescriptor_NetworkType { 993 | if m != nil && m.NetworkType != nil { 994 | return *m.NetworkType 995 | } 996 | return NetworkOperatorSettings_NetworkDescriptor_GSM 997 | } 998 | 999 | type NetworkDataSettings struct { 1000 | APN *string `protobuf:"bytes,1,opt,name=APN" json:"APN,omitempty"` 1001 | XXX_NoUnkeyedLiteral struct{} `json:"-"` 1002 | XXX_unrecognized []byte `json:"-"` 1003 | XXX_sizecache int32 `json:"-"` 1004 | } 1005 | 1006 | func (m *NetworkDataSettings) Reset() { *m = NetworkDataSettings{} } 1007 | func (m *NetworkDataSettings) String() string { return proto.CompactTextString(m) } 1008 | func (*NetworkDataSettings) ProtoMessage() {} 1009 | func (*NetworkDataSettings) Descriptor() ([]byte, []int) { 1010 | return fileDescriptor_df5aea3535dd3286, []int{9} 1011 | } 1012 | 1013 | func (m *NetworkDataSettings) XXX_Unmarshal(b []byte) error { 1014 | return xxx_messageInfo_NetworkDataSettings.Unmarshal(m, b) 1015 | } 1016 | func (m *NetworkDataSettings) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 1017 | return xxx_messageInfo_NetworkDataSettings.Marshal(b, m, deterministic) 1018 | } 1019 | func (m *NetworkDataSettings) XXX_Merge(src proto.Message) { 1020 | xxx_messageInfo_NetworkDataSettings.Merge(m, src) 1021 | } 1022 | func (m *NetworkDataSettings) XXX_Size() int { 1023 | return xxx_messageInfo_NetworkDataSettings.Size(m) 1024 | } 1025 | func (m *NetworkDataSettings) XXX_DiscardUnknown() { 1026 | xxx_messageInfo_NetworkDataSettings.DiscardUnknown(m) 1027 | } 1028 | 1029 | var xxx_messageInfo_NetworkDataSettings proto.InternalMessageInfo 1030 | 1031 | func (m *NetworkDataSettings) GetAPN() string { 1032 | if m != nil && m.APN != nil { 1033 | return *m.APN 1034 | } 1035 | return "" 1036 | } 1037 | 1038 | type ServerConnectSettings struct { 1039 | Host *string `protobuf:"bytes,1,opt,name=host" json:"host,omitempty"` 1040 | Port *uint32 `protobuf:"varint,2,opt,name=port" json:"port,omitempty"` 1041 | XXX_NoUnkeyedLiteral struct{} `json:"-"` 1042 | XXX_unrecognized []byte `json:"-"` 1043 | XXX_sizecache int32 `json:"-"` 1044 | } 1045 | 1046 | func (m *ServerConnectSettings) Reset() { *m = ServerConnectSettings{} } 1047 | func (m *ServerConnectSettings) String() string { return proto.CompactTextString(m) } 1048 | func (*ServerConnectSettings) ProtoMessage() {} 1049 | func (*ServerConnectSettings) Descriptor() ([]byte, []int) { 1050 | return fileDescriptor_df5aea3535dd3286, []int{10} 1051 | } 1052 | 1053 | func (m *ServerConnectSettings) XXX_Unmarshal(b []byte) error { 1054 | return xxx_messageInfo_ServerConnectSettings.Unmarshal(m, b) 1055 | } 1056 | func (m *ServerConnectSettings) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 1057 | return xxx_messageInfo_ServerConnectSettings.Marshal(b, m, deterministic) 1058 | } 1059 | func (m *ServerConnectSettings) XXX_Merge(src proto.Message) { 1060 | xxx_messageInfo_ServerConnectSettings.Merge(m, src) 1061 | } 1062 | func (m *ServerConnectSettings) XXX_Size() int { 1063 | return xxx_messageInfo_ServerConnectSettings.Size(m) 1064 | } 1065 | func (m *ServerConnectSettings) XXX_DiscardUnknown() { 1066 | xxx_messageInfo_ServerConnectSettings.DiscardUnknown(m) 1067 | } 1068 | 1069 | var xxx_messageInfo_ServerConnectSettings proto.InternalMessageInfo 1070 | 1071 | func (m *ServerConnectSettings) GetHost() string { 1072 | if m != nil && m.Host != nil { 1073 | return *m.Host 1074 | } 1075 | return "" 1076 | } 1077 | 1078 | func (m *ServerConnectSettings) GetPort() uint32 { 1079 | if m != nil && m.Port != nil { 1080 | return *m.Port 1081 | } 1082 | return 0 1083 | } 1084 | 1085 | type ModemConfigurationCommand struct { 1086 | NetworkOperatorSettings *NetworkOperatorSettings `protobuf:"bytes,1,opt,name=networkOperatorSettings" json:"networkOperatorSettings,omitempty"` 1087 | NetworkDataSettings *NetworkDataSettings `protobuf:"bytes,2,opt,name=networkDataSettings" json:"networkDataSettings,omitempty"` 1088 | ServerConnectSettings *ServerConnectSettings `protobuf:"bytes,3,opt,name=serverConnectSettings" json:"serverConnectSettings,omitempty"` 1089 | XXX_NoUnkeyedLiteral struct{} `json:"-"` 1090 | XXX_unrecognized []byte `json:"-"` 1091 | XXX_sizecache int32 `json:"-"` 1092 | } 1093 | 1094 | func (m *ModemConfigurationCommand) Reset() { *m = ModemConfigurationCommand{} } 1095 | func (m *ModemConfigurationCommand) String() string { return proto.CompactTextString(m) } 1096 | func (*ModemConfigurationCommand) ProtoMessage() {} 1097 | func (*ModemConfigurationCommand) Descriptor() ([]byte, []int) { 1098 | return fileDescriptor_df5aea3535dd3286, []int{11} 1099 | } 1100 | 1101 | func (m *ModemConfigurationCommand) XXX_Unmarshal(b []byte) error { 1102 | return xxx_messageInfo_ModemConfigurationCommand.Unmarshal(m, b) 1103 | } 1104 | func (m *ModemConfigurationCommand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 1105 | return xxx_messageInfo_ModemConfigurationCommand.Marshal(b, m, deterministic) 1106 | } 1107 | func (m *ModemConfigurationCommand) XXX_Merge(src proto.Message) { 1108 | xxx_messageInfo_ModemConfigurationCommand.Merge(m, src) 1109 | } 1110 | func (m *ModemConfigurationCommand) XXX_Size() int { 1111 | return xxx_messageInfo_ModemConfigurationCommand.Size(m) 1112 | } 1113 | func (m *ModemConfigurationCommand) XXX_DiscardUnknown() { 1114 | xxx_messageInfo_ModemConfigurationCommand.DiscardUnknown(m) 1115 | } 1116 | 1117 | var xxx_messageInfo_ModemConfigurationCommand proto.InternalMessageInfo 1118 | 1119 | func (m *ModemConfigurationCommand) GetNetworkOperatorSettings() *NetworkOperatorSettings { 1120 | if m != nil { 1121 | return m.NetworkOperatorSettings 1122 | } 1123 | return nil 1124 | } 1125 | 1126 | func (m *ModemConfigurationCommand) GetNetworkDataSettings() *NetworkDataSettings { 1127 | if m != nil { 1128 | return m.NetworkDataSettings 1129 | } 1130 | return nil 1131 | } 1132 | 1133 | func (m *ModemConfigurationCommand) GetServerConnectSettings() *ServerConnectSettings { 1134 | if m != nil { 1135 | return m.ServerConnectSettings 1136 | } 1137 | return nil 1138 | } 1139 | 1140 | type RTCConfigurationCommand struct { 1141 | UnixTime *uint32 `protobuf:"varint,1,opt,name=unix_time,json=unixTime" json:"unix_time,omitempty"` 1142 | XXX_NoUnkeyedLiteral struct{} `json:"-"` 1143 | XXX_unrecognized []byte `json:"-"` 1144 | XXX_sizecache int32 `json:"-"` 1145 | } 1146 | 1147 | func (m *RTCConfigurationCommand) Reset() { *m = RTCConfigurationCommand{} } 1148 | func (m *RTCConfigurationCommand) String() string { return proto.CompactTextString(m) } 1149 | func (*RTCConfigurationCommand) ProtoMessage() {} 1150 | func (*RTCConfigurationCommand) Descriptor() ([]byte, []int) { 1151 | return fileDescriptor_df5aea3535dd3286, []int{12} 1152 | } 1153 | 1154 | func (m *RTCConfigurationCommand) XXX_Unmarshal(b []byte) error { 1155 | return xxx_messageInfo_RTCConfigurationCommand.Unmarshal(m, b) 1156 | } 1157 | func (m *RTCConfigurationCommand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 1158 | return xxx_messageInfo_RTCConfigurationCommand.Marshal(b, m, deterministic) 1159 | } 1160 | func (m *RTCConfigurationCommand) XXX_Merge(src proto.Message) { 1161 | xxx_messageInfo_RTCConfigurationCommand.Merge(m, src) 1162 | } 1163 | func (m *RTCConfigurationCommand) XXX_Size() int { 1164 | return xxx_messageInfo_RTCConfigurationCommand.Size(m) 1165 | } 1166 | func (m *RTCConfigurationCommand) XXX_DiscardUnknown() { 1167 | xxx_messageInfo_RTCConfigurationCommand.DiscardUnknown(m) 1168 | } 1169 | 1170 | var xxx_messageInfo_RTCConfigurationCommand proto.InternalMessageInfo 1171 | 1172 | func (m *RTCConfigurationCommand) GetUnixTime() uint32 { 1173 | if m != nil && m.UnixTime != nil { 1174 | return *m.UnixTime 1175 | } 1176 | return 0 1177 | } 1178 | 1179 | type CommandResponse struct { 1180 | Type *ControlCommand_Type `protobuf:"varint,1,opt,name=type,enum=openxc.ControlCommand_Type" json:"type,omitempty"` 1181 | Message *string `protobuf:"bytes,2,opt,name=message" json:"message,omitempty"` 1182 | Status *bool `protobuf:"varint,3,opt,name=status" json:"status,omitempty"` 1183 | XXX_NoUnkeyedLiteral struct{} `json:"-"` 1184 | XXX_unrecognized []byte `json:"-"` 1185 | XXX_sizecache int32 `json:"-"` 1186 | } 1187 | 1188 | func (m *CommandResponse) Reset() { *m = CommandResponse{} } 1189 | func (m *CommandResponse) String() string { return proto.CompactTextString(m) } 1190 | func (*CommandResponse) ProtoMessage() {} 1191 | func (*CommandResponse) Descriptor() ([]byte, []int) { 1192 | return fileDescriptor_df5aea3535dd3286, []int{13} 1193 | } 1194 | 1195 | func (m *CommandResponse) XXX_Unmarshal(b []byte) error { 1196 | return xxx_messageInfo_CommandResponse.Unmarshal(m, b) 1197 | } 1198 | func (m *CommandResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 1199 | return xxx_messageInfo_CommandResponse.Marshal(b, m, deterministic) 1200 | } 1201 | func (m *CommandResponse) XXX_Merge(src proto.Message) { 1202 | xxx_messageInfo_CommandResponse.Merge(m, src) 1203 | } 1204 | func (m *CommandResponse) XXX_Size() int { 1205 | return xxx_messageInfo_CommandResponse.Size(m) 1206 | } 1207 | func (m *CommandResponse) XXX_DiscardUnknown() { 1208 | xxx_messageInfo_CommandResponse.DiscardUnknown(m) 1209 | } 1210 | 1211 | var xxx_messageInfo_CommandResponse proto.InternalMessageInfo 1212 | 1213 | func (m *CommandResponse) GetType() ControlCommand_Type { 1214 | if m != nil && m.Type != nil { 1215 | return *m.Type 1216 | } 1217 | return ControlCommand_VERSION 1218 | } 1219 | 1220 | func (m *CommandResponse) GetMessage() string { 1221 | if m != nil && m.Message != nil { 1222 | return *m.Message 1223 | } 1224 | return "" 1225 | } 1226 | 1227 | func (m *CommandResponse) GetStatus() bool { 1228 | if m != nil && m.Status != nil { 1229 | return *m.Status 1230 | } 1231 | return false 1232 | } 1233 | 1234 | type DiagnosticRequest struct { 1235 | Bus *int32 `protobuf:"varint,1,opt,name=bus" json:"bus,omitempty"` 1236 | MessageId *uint32 `protobuf:"varint,2,opt,name=message_id,json=messageId" json:"message_id,omitempty"` 1237 | Mode *uint32 `protobuf:"varint,3,opt,name=mode" json:"mode,omitempty"` 1238 | Pid *uint32 `protobuf:"varint,4,opt,name=pid" json:"pid,omitempty"` 1239 | // TODO we are capping this at 8 bytes for now - need to change when we 1240 | // support multi-frame responses 1241 | Payload []byte `protobuf:"bytes,5,opt,name=payload" json:"payload,omitempty"` 1242 | MultipleResponses *bool `protobuf:"varint,6,opt,name=multiple_responses,json=multipleResponses" json:"multiple_responses,omitempty"` 1243 | Frequency *float64 `protobuf:"fixed64,7,opt,name=frequency" json:"frequency,omitempty"` 1244 | Name *string `protobuf:"bytes,8,opt,name=name" json:"name,omitempty"` 1245 | DecodedType *DiagnosticRequest_DecodedType `protobuf:"varint,9,opt,name=decoded_type,json=decodedType,enum=openxc.DiagnosticRequest_DecodedType" json:"decoded_type,omitempty"` 1246 | XXX_NoUnkeyedLiteral struct{} `json:"-"` 1247 | XXX_unrecognized []byte `json:"-"` 1248 | XXX_sizecache int32 `json:"-"` 1249 | } 1250 | 1251 | func (m *DiagnosticRequest) Reset() { *m = DiagnosticRequest{} } 1252 | func (m *DiagnosticRequest) String() string { return proto.CompactTextString(m) } 1253 | func (*DiagnosticRequest) ProtoMessage() {} 1254 | func (*DiagnosticRequest) Descriptor() ([]byte, []int) { 1255 | return fileDescriptor_df5aea3535dd3286, []int{14} 1256 | } 1257 | 1258 | func (m *DiagnosticRequest) XXX_Unmarshal(b []byte) error { 1259 | return xxx_messageInfo_DiagnosticRequest.Unmarshal(m, b) 1260 | } 1261 | func (m *DiagnosticRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 1262 | return xxx_messageInfo_DiagnosticRequest.Marshal(b, m, deterministic) 1263 | } 1264 | func (m *DiagnosticRequest) XXX_Merge(src proto.Message) { 1265 | xxx_messageInfo_DiagnosticRequest.Merge(m, src) 1266 | } 1267 | func (m *DiagnosticRequest) XXX_Size() int { 1268 | return xxx_messageInfo_DiagnosticRequest.Size(m) 1269 | } 1270 | func (m *DiagnosticRequest) XXX_DiscardUnknown() { 1271 | xxx_messageInfo_DiagnosticRequest.DiscardUnknown(m) 1272 | } 1273 | 1274 | var xxx_messageInfo_DiagnosticRequest proto.InternalMessageInfo 1275 | 1276 | func (m *DiagnosticRequest) GetBus() int32 { 1277 | if m != nil && m.Bus != nil { 1278 | return *m.Bus 1279 | } 1280 | return 0 1281 | } 1282 | 1283 | func (m *DiagnosticRequest) GetMessageId() uint32 { 1284 | if m != nil && m.MessageId != nil { 1285 | return *m.MessageId 1286 | } 1287 | return 0 1288 | } 1289 | 1290 | func (m *DiagnosticRequest) GetMode() uint32 { 1291 | if m != nil && m.Mode != nil { 1292 | return *m.Mode 1293 | } 1294 | return 0 1295 | } 1296 | 1297 | func (m *DiagnosticRequest) GetPid() uint32 { 1298 | if m != nil && m.Pid != nil { 1299 | return *m.Pid 1300 | } 1301 | return 0 1302 | } 1303 | 1304 | func (m *DiagnosticRequest) GetPayload() []byte { 1305 | if m != nil { 1306 | return m.Payload 1307 | } 1308 | return nil 1309 | } 1310 | 1311 | func (m *DiagnosticRequest) GetMultipleResponses() bool { 1312 | if m != nil && m.MultipleResponses != nil { 1313 | return *m.MultipleResponses 1314 | } 1315 | return false 1316 | } 1317 | 1318 | func (m *DiagnosticRequest) GetFrequency() float64 { 1319 | if m != nil && m.Frequency != nil { 1320 | return *m.Frequency 1321 | } 1322 | return 0 1323 | } 1324 | 1325 | func (m *DiagnosticRequest) GetName() string { 1326 | if m != nil && m.Name != nil { 1327 | return *m.Name 1328 | } 1329 | return "" 1330 | } 1331 | 1332 | func (m *DiagnosticRequest) GetDecodedType() DiagnosticRequest_DecodedType { 1333 | if m != nil && m.DecodedType != nil { 1334 | return *m.DecodedType 1335 | } 1336 | return DiagnosticRequest_NONE 1337 | } 1338 | 1339 | type DiagnosticResponse struct { 1340 | Bus *int32 `protobuf:"varint,1,opt,name=bus" json:"bus,omitempty"` 1341 | MessageId *uint32 `protobuf:"varint,2,opt,name=message_id,json=messageId" json:"message_id,omitempty"` 1342 | Mode *uint32 `protobuf:"varint,3,opt,name=mode" json:"mode,omitempty"` 1343 | Pid *uint32 `protobuf:"varint,4,opt,name=pid" json:"pid,omitempty"` 1344 | Success *bool `protobuf:"varint,5,opt,name=success" json:"success,omitempty"` 1345 | NegativeResponseCode *uint32 `protobuf:"varint,6,opt,name=negative_response_code,json=negativeResponseCode" json:"negative_response_code,omitempty"` 1346 | // TODO we are capping this at 8 bytes for now - need to change when we 1347 | // support multi-frame responses 1348 | Payload []byte `protobuf:"bytes,7,opt,name=payload" json:"payload,omitempty"` 1349 | Value *float64 `protobuf:"fixed64,8,opt,name=value" json:"value,omitempty"` 1350 | XXX_NoUnkeyedLiteral struct{} `json:"-"` 1351 | XXX_unrecognized []byte `json:"-"` 1352 | XXX_sizecache int32 `json:"-"` 1353 | } 1354 | 1355 | func (m *DiagnosticResponse) Reset() { *m = DiagnosticResponse{} } 1356 | func (m *DiagnosticResponse) String() string { return proto.CompactTextString(m) } 1357 | func (*DiagnosticResponse) ProtoMessage() {} 1358 | func (*DiagnosticResponse) Descriptor() ([]byte, []int) { 1359 | return fileDescriptor_df5aea3535dd3286, []int{15} 1360 | } 1361 | 1362 | func (m *DiagnosticResponse) XXX_Unmarshal(b []byte) error { 1363 | return xxx_messageInfo_DiagnosticResponse.Unmarshal(m, b) 1364 | } 1365 | func (m *DiagnosticResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 1366 | return xxx_messageInfo_DiagnosticResponse.Marshal(b, m, deterministic) 1367 | } 1368 | func (m *DiagnosticResponse) XXX_Merge(src proto.Message) { 1369 | xxx_messageInfo_DiagnosticResponse.Merge(m, src) 1370 | } 1371 | func (m *DiagnosticResponse) XXX_Size() int { 1372 | return xxx_messageInfo_DiagnosticResponse.Size(m) 1373 | } 1374 | func (m *DiagnosticResponse) XXX_DiscardUnknown() { 1375 | xxx_messageInfo_DiagnosticResponse.DiscardUnknown(m) 1376 | } 1377 | 1378 | var xxx_messageInfo_DiagnosticResponse proto.InternalMessageInfo 1379 | 1380 | func (m *DiagnosticResponse) GetBus() int32 { 1381 | if m != nil && m.Bus != nil { 1382 | return *m.Bus 1383 | } 1384 | return 0 1385 | } 1386 | 1387 | func (m *DiagnosticResponse) GetMessageId() uint32 { 1388 | if m != nil && m.MessageId != nil { 1389 | return *m.MessageId 1390 | } 1391 | return 0 1392 | } 1393 | 1394 | func (m *DiagnosticResponse) GetMode() uint32 { 1395 | if m != nil && m.Mode != nil { 1396 | return *m.Mode 1397 | } 1398 | return 0 1399 | } 1400 | 1401 | func (m *DiagnosticResponse) GetPid() uint32 { 1402 | if m != nil && m.Pid != nil { 1403 | return *m.Pid 1404 | } 1405 | return 0 1406 | } 1407 | 1408 | func (m *DiagnosticResponse) GetSuccess() bool { 1409 | if m != nil && m.Success != nil { 1410 | return *m.Success 1411 | } 1412 | return false 1413 | } 1414 | 1415 | func (m *DiagnosticResponse) GetNegativeResponseCode() uint32 { 1416 | if m != nil && m.NegativeResponseCode != nil { 1417 | return *m.NegativeResponseCode 1418 | } 1419 | return 0 1420 | } 1421 | 1422 | func (m *DiagnosticResponse) GetPayload() []byte { 1423 | if m != nil { 1424 | return m.Payload 1425 | } 1426 | return nil 1427 | } 1428 | 1429 | func (m *DiagnosticResponse) GetValue() float64 { 1430 | if m != nil && m.Value != nil { 1431 | return *m.Value 1432 | } 1433 | return 0 1434 | } 1435 | 1436 | type DynamicField struct { 1437 | Type *DynamicField_Type `protobuf:"varint,1,opt,name=type,enum=openxc.DynamicField_Type" json:"type,omitempty"` 1438 | StringValue *string `protobuf:"bytes,2,opt,name=string_value,json=stringValue" json:"string_value,omitempty"` 1439 | NumericValue *float64 `protobuf:"fixed64,3,opt,name=numeric_value,json=numericValue" json:"numeric_value,omitempty"` 1440 | BooleanValue *bool `protobuf:"varint,4,opt,name=boolean_value,json=booleanValue" json:"boolean_value,omitempty"` 1441 | XXX_NoUnkeyedLiteral struct{} `json:"-"` 1442 | XXX_unrecognized []byte `json:"-"` 1443 | XXX_sizecache int32 `json:"-"` 1444 | } 1445 | 1446 | func (m *DynamicField) Reset() { *m = DynamicField{} } 1447 | func (m *DynamicField) String() string { return proto.CompactTextString(m) } 1448 | func (*DynamicField) ProtoMessage() {} 1449 | func (*DynamicField) Descriptor() ([]byte, []int) { 1450 | return fileDescriptor_df5aea3535dd3286, []int{16} 1451 | } 1452 | 1453 | func (m *DynamicField) XXX_Unmarshal(b []byte) error { 1454 | return xxx_messageInfo_DynamicField.Unmarshal(m, b) 1455 | } 1456 | func (m *DynamicField) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 1457 | return xxx_messageInfo_DynamicField.Marshal(b, m, deterministic) 1458 | } 1459 | func (m *DynamicField) XXX_Merge(src proto.Message) { 1460 | xxx_messageInfo_DynamicField.Merge(m, src) 1461 | } 1462 | func (m *DynamicField) XXX_Size() int { 1463 | return xxx_messageInfo_DynamicField.Size(m) 1464 | } 1465 | func (m *DynamicField) XXX_DiscardUnknown() { 1466 | xxx_messageInfo_DynamicField.DiscardUnknown(m) 1467 | } 1468 | 1469 | var xxx_messageInfo_DynamicField proto.InternalMessageInfo 1470 | 1471 | func (m *DynamicField) GetType() DynamicField_Type { 1472 | if m != nil && m.Type != nil { 1473 | return *m.Type 1474 | } 1475 | return DynamicField_STRING 1476 | } 1477 | 1478 | func (m *DynamicField) GetStringValue() string { 1479 | if m != nil && m.StringValue != nil { 1480 | return *m.StringValue 1481 | } 1482 | return "" 1483 | } 1484 | 1485 | func (m *DynamicField) GetNumericValue() float64 { 1486 | if m != nil && m.NumericValue != nil { 1487 | return *m.NumericValue 1488 | } 1489 | return 0 1490 | } 1491 | 1492 | func (m *DynamicField) GetBooleanValue() bool { 1493 | if m != nil && m.BooleanValue != nil { 1494 | return *m.BooleanValue 1495 | } 1496 | return false 1497 | } 1498 | 1499 | type SimpleMessage struct { 1500 | Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` 1501 | Value *DynamicField `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"` 1502 | Event *DynamicField `protobuf:"bytes,3,opt,name=event" json:"event,omitempty"` 1503 | XXX_NoUnkeyedLiteral struct{} `json:"-"` 1504 | XXX_unrecognized []byte `json:"-"` 1505 | XXX_sizecache int32 `json:"-"` 1506 | } 1507 | 1508 | func (m *SimpleMessage) Reset() { *m = SimpleMessage{} } 1509 | func (m *SimpleMessage) String() string { return proto.CompactTextString(m) } 1510 | func (*SimpleMessage) ProtoMessage() {} 1511 | func (*SimpleMessage) Descriptor() ([]byte, []int) { 1512 | return fileDescriptor_df5aea3535dd3286, []int{17} 1513 | } 1514 | 1515 | func (m *SimpleMessage) XXX_Unmarshal(b []byte) error { 1516 | return xxx_messageInfo_SimpleMessage.Unmarshal(m, b) 1517 | } 1518 | func (m *SimpleMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 1519 | return xxx_messageInfo_SimpleMessage.Marshal(b, m, deterministic) 1520 | } 1521 | func (m *SimpleMessage) XXX_Merge(src proto.Message) { 1522 | xxx_messageInfo_SimpleMessage.Merge(m, src) 1523 | } 1524 | func (m *SimpleMessage) XXX_Size() int { 1525 | return xxx_messageInfo_SimpleMessage.Size(m) 1526 | } 1527 | func (m *SimpleMessage) XXX_DiscardUnknown() { 1528 | xxx_messageInfo_SimpleMessage.DiscardUnknown(m) 1529 | } 1530 | 1531 | var xxx_messageInfo_SimpleMessage proto.InternalMessageInfo 1532 | 1533 | func (m *SimpleMessage) GetName() string { 1534 | if m != nil && m.Name != nil { 1535 | return *m.Name 1536 | } 1537 | return "" 1538 | } 1539 | 1540 | func (m *SimpleMessage) GetValue() *DynamicField { 1541 | if m != nil { 1542 | return m.Value 1543 | } 1544 | return nil 1545 | } 1546 | 1547 | func (m *SimpleMessage) GetEvent() *DynamicField { 1548 | if m != nil { 1549 | return m.Event 1550 | } 1551 | return nil 1552 | } 1553 | 1554 | func init() { 1555 | proto.RegisterEnum("openxc.VehicleMessage_Type", VehicleMessage_Type_name, VehicleMessage_Type_value) 1556 | proto.RegisterEnum("openxc.CanMessage_FrameFormat", CanMessage_FrameFormat_name, CanMessage_FrameFormat_value) 1557 | proto.RegisterEnum("openxc.ControlCommand_Type", ControlCommand_Type_name, ControlCommand_Type_value) 1558 | proto.RegisterEnum("openxc.DiagnosticControlCommand_Action", DiagnosticControlCommand_Action_name, DiagnosticControlCommand_Action_value) 1559 | proto.RegisterEnum("openxc.PayloadFormatCommand_PayloadFormat", PayloadFormatCommand_PayloadFormat_name, PayloadFormatCommand_PayloadFormat_value) 1560 | proto.RegisterEnum("openxc.NetworkOperatorSettings_OperatorSelectMode", NetworkOperatorSettings_OperatorSelectMode_name, NetworkOperatorSettings_OperatorSelectMode_value) 1561 | proto.RegisterEnum("openxc.NetworkOperatorSettings_NetworkDescriptor_NetworkType", NetworkOperatorSettings_NetworkDescriptor_NetworkType_name, NetworkOperatorSettings_NetworkDescriptor_NetworkType_value) 1562 | proto.RegisterEnum("openxc.DiagnosticRequest_DecodedType", DiagnosticRequest_DecodedType_name, DiagnosticRequest_DecodedType_value) 1563 | proto.RegisterEnum("openxc.DynamicField_Type", DynamicField_Type_name, DynamicField_Type_value) 1564 | proto.RegisterType((*VehicleMessage)(nil), "openxc.VehicleMessage") 1565 | proto.RegisterType((*CanMessage)(nil), "openxc.CanMessage") 1566 | proto.RegisterType((*ControlCommand)(nil), "openxc.ControlCommand") 1567 | proto.RegisterType((*DiagnosticControlCommand)(nil), "openxc.DiagnosticControlCommand") 1568 | proto.RegisterType((*PassthroughModeControlCommand)(nil), "openxc.PassthroughModeControlCommand") 1569 | proto.RegisterType((*AcceptanceFilterBypassCommand)(nil), "openxc.AcceptanceFilterBypassCommand") 1570 | proto.RegisterType((*PayloadFormatCommand)(nil), "openxc.PayloadFormatCommand") 1571 | proto.RegisterType((*PredefinedObd2RequestsCommand)(nil), "openxc.PredefinedObd2RequestsCommand") 1572 | proto.RegisterType((*NetworkOperatorSettings)(nil), "openxc.NetworkOperatorSettings") 1573 | proto.RegisterType((*NetworkOperatorSettings_NetworkDescriptor)(nil), "openxc.NetworkOperatorSettings.NetworkDescriptor") 1574 | proto.RegisterType((*NetworkDataSettings)(nil), "openxc.NetworkDataSettings") 1575 | proto.RegisterType((*ServerConnectSettings)(nil), "openxc.ServerConnectSettings") 1576 | proto.RegisterType((*ModemConfigurationCommand)(nil), "openxc.ModemConfigurationCommand") 1577 | proto.RegisterType((*RTCConfigurationCommand)(nil), "openxc.RTCConfigurationCommand") 1578 | proto.RegisterType((*CommandResponse)(nil), "openxc.CommandResponse") 1579 | proto.RegisterType((*DiagnosticRequest)(nil), "openxc.DiagnosticRequest") 1580 | proto.RegisterType((*DiagnosticResponse)(nil), "openxc.DiagnosticResponse") 1581 | proto.RegisterType((*DynamicField)(nil), "openxc.DynamicField") 1582 | proto.RegisterType((*SimpleMessage)(nil), "openxc.SimpleMessage") 1583 | } 1584 | 1585 | func init() { proto.RegisterFile("openxc.proto", fileDescriptor_df5aea3535dd3286) } 1586 | 1587 | var fileDescriptor_df5aea3535dd3286 = []byte{ 1588 | // 1720 bytes of a gzipped FileDescriptorProto 1589 | 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x57, 0xdd, 0x6e, 0xdb, 0xc8, 1590 | 0x15, 0x5e, 0x4a, 0xb2, 0x25, 0x1d, 0xfd, 0x98, 0x1e, 0x3b, 0xb6, 0xb2, 0x89, 0xbb, 0x0e, 0x8b, 1591 | 0x60, 0xd3, 0x00, 0x75, 0x51, 0x6f, 0x51, 0xb4, 0x40, 0x8b, 0x80, 0x22, 0x29, 0x47, 0x8d, 0x44, 1592 | 0xaa, 0x43, 0xca, 0x68, 0xd0, 0x0b, 0x62, 0x4c, 0x8e, 0x1d, 0xa2, 0xe2, 0x4f, 0x49, 0x2a, 0xbb, 1593 | 0x46, 0x5f, 0xa3, 0x57, 0x05, 0xfa, 0x04, 0xbd, 0x68, 0x1f, 0xa5, 0xed, 0x43, 0xf4, 0xa6, 0xaf, 1594 | 0xd0, 0x8b, 0x62, 0x86, 0x43, 0xfd, 0x58, 0x92, 0x83, 0x5c, 0xec, 0xdd, 0xcc, 0x39, 0xdf, 0x39, 1595 | 0x67, 0xe6, 0xfc, 0xcd, 0x19, 0x68, 0xc7, 0x09, 0x8d, 0xbe, 0xf3, 0x2e, 0x92, 0x34, 0xce, 0x63, 1596 | 0xb4, 0x5f, 0xec, 0x94, 0xff, 0x55, 0xa1, 0x7b, 0x4d, 0x3f, 0x04, 0xde, 0x8c, 0x8e, 0x69, 0x96, 1597 | 0x91, 0x3b, 0x8a, 0x7e, 0x02, 0xb5, 0xfc, 0x3e, 0xa1, 0x3d, 0xe9, 0x5c, 0x7a, 0xd5, 0xbd, 0x7c, 1598 | 0x76, 0x21, 0xe4, 0xd6, 0x51, 0x17, 0xce, 0x7d, 0x42, 0x31, 0x07, 0xa2, 0x6f, 0xa0, 0xe5, 0x91, 1599 | 0xc8, 0x0d, 0x0b, 0x4e, 0xaf, 0x72, 0x2e, 0xbd, 0x6a, 0x5d, 0xa2, 0x52, 0x4e, 0x23, 0x91, 0x90, 1600 | 0xc1, 0xe0, 0x2d, 0xd6, 0xe8, 0x57, 0xd0, 0xcd, 0x82, 0x30, 0x99, 0xd1, 0x85, 0x5c, 0x95, 0xcb, 1601 | 0x3d, 0x29, 0xe5, 0x6c, 0xce, 0x2d, 0x45, 0x3b, 0xd9, 0xea, 0x16, 0xbd, 0x83, 0x23, 0x3f, 0x20, 1602 | 0x77, 0x51, 0x9c, 0xe5, 0x81, 0xe7, 0xa6, 0x34, 0x4b, 0xe2, 0x28, 0xa3, 0xbd, 0x1a, 0x57, 0xf1, 1603 | 0x65, 0xa9, 0x42, 0x5f, 0x40, 0xb0, 0x40, 0x60, 0xe4, 0x6f, 0xd0, 0xd0, 0x1b, 0x38, 0xf0, 0xe2, 1604 | 0x28, 0x4f, 0xe3, 0x99, 0xeb, 0xc5, 0x61, 0x48, 0x22, 0xbf, 0xb7, 0xc7, 0x15, 0x9d, 0x2c, 0xee, 1605 | 0x50, 0xb0, 0xb5, 0x82, 0x8b, 0xbb, 0xde, 0xda, 0x1e, 0xf5, 0x41, 0x16, 0x82, 0xcb, 0xa3, 0xec, 1606 | 0x73, 0x0d, 0xa7, 0x4b, 0x0d, 0x85, 0x68, 0x79, 0x8e, 0x03, 0x6f, 0x9d, 0x80, 0x9e, 0x43, 0x33, 1607 | 0x0f, 0x42, 0x9a, 0xe5, 0x24, 0x4c, 0x7a, 0xf5, 0x73, 0xe9, 0x55, 0x0d, 0x2f, 0x09, 0xca, 0x35, 1608 | 0xd4, 0x98, 0xc3, 0x51, 0x1d, 0xaa, 0x9a, 0x6a, 0xca, 0x12, 0x02, 0xd8, 0xb7, 0x87, 0xe3, 0xc9, 1609 | 0xc8, 0x90, 0x2b, 0xa8, 0x0b, 0xa0, 0x0f, 0xd5, 0x2b, 0xd3, 0xb2, 0x9d, 0xa1, 0x26, 0x57, 0xd1, 1610 | 0x11, 0x1c, 0x68, 0x96, 0xe9, 0x60, 0x6b, 0xe4, 0x6a, 0xd6, 0x78, 0xac, 0x9a, 0xba, 0x5c, 0x43, 1611 | 0xc7, 0x20, 0x8b, 0x8d, 0x8b, 0x0d, 0x7b, 0x62, 0x99, 0xb6, 0x21, 0xef, 0x29, 0xff, 0x90, 0x00, 1612 | 0x96, 0x01, 0x42, 0x32, 0x54, 0x6f, 0xe6, 0x19, 0x8f, 0xfc, 0x1e, 0x66, 0x4b, 0xd4, 0x85, 0x4a, 1613 | 0xe0, 0xf3, 0x90, 0x76, 0x70, 0x25, 0xf0, 0x11, 0x82, 0x9a, 0x4f, 0x72, 0xc2, 0x83, 0xd5, 0xc6, 1614 | 0x7c, 0x8d, 0x54, 0x68, 0xdf, 0xa6, 0x24, 0xa4, 0xee, 0x6d, 0x9c, 0x86, 0x24, 0xe7, 0x51, 0xe8, 1615 | 0x5e, 0xfe, 0x60, 0x33, 0x01, 0x2e, 0x06, 0x0c, 0x36, 0xe0, 0x28, 0xdc, 0xba, 0x5d, 0x6e, 0x94, 1616 | 0x1f, 0x41, 0x6b, 0x85, 0x87, 0xda, 0xd0, 0xb0, 0x1d, 0xd5, 0xd4, 0x55, 0xac, 0xcb, 0x12, 0xdb, 1617 | 0x19, 0xbf, 0x73, 0x0c, 0x53, 0x37, 0x74, 0xb9, 0xa2, 0xfc, 0xb3, 0x0e, 0xdd, 0xf5, 0x78, 0xec, 1618 | 0xca, 0xd8, 0x75, 0xd4, 0x6a, 0xc6, 0x5a, 0x80, 0xd6, 0xd2, 0xe7, 0x8f, 0x73, 0x9a, 0xe5, 0x22, 1619 | 0x71, 0xcf, 0x37, 0xb3, 0xe7, 0x41, 0xf8, 0x0f, 0x57, 0x73, 0x88, 0x8b, 0x22, 0x17, 0x7a, 0x09, 1620 | 0xc9, 0xb2, 0xfc, 0x43, 0x1a, 0xcf, 0xef, 0x3e, 0xb8, 0x61, 0xec, 0xd3, 0x85, 0xda, 0x22, 0xaf, 1621 | 0x5f, 0x96, 0x6a, 0x27, 0x4b, 0xdc, 0x38, 0xf6, 0xe9, 0x03, 0xdd, 0x27, 0xc9, 0x3a, 0xbb, 0x34, 1622 | 0x10, 0xc1, 0x39, 0xf1, 0x3c, 0x9a, 0xe4, 0x24, 0xf2, 0xa8, 0x7b, 0x1b, 0xcc, 0x72, 0x9a, 0xba, 1623 | 0x37, 0xf7, 0x0c, 0xbd, 0x48, 0xda, 0xda, 0xba, 0x21, 0x75, 0x81, 0x1f, 0x70, 0x78, 0x9f, 0xa3, 1624 | 0x4b, 0x43, 0x67, 0xe4, 0x31, 0x36, 0xc2, 0x70, 0x92, 0x90, 0xfb, 0x59, 0x4c, 0x7c, 0x11, 0xd5, 1625 | 0x07, 0xa5, 0xf1, 0x7c, 0x79, 0x1d, 0x8e, 0x2a, 0x02, 0x57, 0x2a, 0x3f, 0x4e, 0xb6, 0x50, 0xd9, 1626 | 0x1d, 0x92, 0x94, 0xfa, 0xf4, 0x36, 0x88, 0xa8, 0xef, 0xc6, 0x37, 0xfe, 0x65, 0xe9, 0xa3, 0xe5, 1627 | 0x1d, 0xf6, 0x1f, 0x38, 0x6b, 0x81, 0xb7, 0x6e, 0xfc, 0x4b, 0xe1, 0x8c, 0xe5, 0x1d, 0x92, 0xc7, 1628 | 0xd8, 0x88, 0xc0, 0x33, 0x16, 0x88, 0xd0, 0xf5, 0xe2, 0xe8, 0x36, 0xb8, 0x9b, 0xa7, 0x24, 0x0f, 1629 | 0xe2, 0x68, 0x61, 0xaa, 0xce, 0x4d, 0xbd, 0x28, 0x4d, 0x31, 0x6f, 0x87, 0xda, 0x2a, 0xb2, 0x34, 1630 | 0xf3, 0x34, 0xdc, 0xc5, 0x42, 0xbf, 0x87, 0xa7, 0x69, 0xee, 0xed, 0x30, 0xd0, 0xe0, 0x06, 0xbe, 1631 | 0x2a, 0x0d, 0x60, 0x47, 0xdb, 0xaa, 0xfe, 0x34, 0xcd, 0xbd, 0x6d, 0x0c, 0xe5, 0x3f, 0x92, 0xa8, 1632 | 0xfa, 0x16, 0xd4, 0xaf, 0x0d, 0x6c, 0x0f, 0x2d, 0x56, 0xf9, 0x1d, 0x68, 0xea, 0xc6, 0xf5, 0x50, 1633 | 0x33, 0xdc, 0xa1, 0xbe, 0xa5, 0xf8, 0x0f, 0xa0, 0x35, 0x51, 0x6d, 0xdb, 0x79, 0x8b, 0xad, 0xe9, 1634 | 0xd5, 0x5b, 0xb9, 0x86, 0x9e, 0x43, 0x4f, 0xd5, 0x34, 0x63, 0xe2, 0xa8, 0xa6, 0x66, 0xb8, 0x83, 1635 | 0xe1, 0xc8, 0x31, 0xb0, 0xdb, 0x7f, 0xcf, 0x40, 0xf2, 0x1e, 0x42, 0xd0, 0x9d, 0xa8, 0xef, 0x47, 1636 | 0x96, 0xaa, 0xbb, 0x03, 0x0b, 0x8f, 0x55, 0x47, 0xde, 0x67, 0x12, 0x13, 0x6c, 0xe8, 0xc6, 0x60, 1637 | 0x68, 0x1a, 0xba, 0x6b, 0xf5, 0xf5, 0x4b, 0x17, 0x1b, 0xbf, 0x9d, 0x1a, 0xb6, 0x63, 0xcb, 0x75, 1638 | 0x74, 0x0a, 0x47, 0x63, 0x4b, 0x37, 0xc6, 0xae, 0x66, 0x99, 0x83, 0xe1, 0xd5, 0x14, 0xab, 0x0e, 1639 | 0x3b, 0x58, 0x03, 0x3d, 0x81, 0x43, 0xec, 0x68, 0x0f, 0xc8, 0x4d, 0xd6, 0x8d, 0x6c, 0xdd, 0x1d, 1640 | 0x5b, 0x53, 0xd3, 0x71, 0x6d, 0x47, 0x75, 0xa6, 0xb6, 0x0c, 0xac, 0xa4, 0x27, 0x23, 0xd5, 0x61, 1641 | 0x26, 0xe5, 0x96, 0xf2, 0x77, 0x09, 0x7a, 0xbb, 0xaa, 0x0d, 0x7d, 0x03, 0xf5, 0xb2, 0x92, 0x24, 1642 | 0xee, 0xd0, 0xa7, 0xdb, 0xda, 0x3b, 0x07, 0xe0, 0x12, 0x89, 0xde, 0xc0, 0x3e, 0xf1, 0x98, 0x2f, 1643 | 0x79, 0x51, 0x77, 0x2f, 0xbf, 0xfe, 0x54, 0x51, 0x5f, 0xa8, 0x1c, 0x8e, 0x85, 0x98, 0x72, 0x06, 1644 | 0xfb, 0x05, 0x85, 0xb5, 0x5c, 0x55, 0xd7, 0x8b, 0x96, 0xab, 0x31, 0x1f, 0x8e, 0xe4, 0x8a, 0xf2, 1645 | 0x0e, 0xce, 0x1e, 0xad, 0xe3, 0x2d, 0x9d, 0xb4, 0x07, 0x75, 0x1a, 0x91, 0x9b, 0x19, 0x2d, 0xda, 1646 | 0x69, 0x03, 0x97, 0x5b, 0x65, 0x08, 0x67, 0x8f, 0xd6, 0xea, 0x16, 0x65, 0x27, 0xb0, 0x5f, 0x14, 1647 | 0xbf, 0xd0, 0x25, 0x76, 0xca, 0x9f, 0x25, 0x38, 0xde, 0x56, 0x91, 0xa8, 0x0f, 0xfb, 0xa2, 0x3b, 1648 | 0x17, 0x4d, 0xf2, 0xf5, 0x63, 0xf5, 0xbb, 0x4e, 0xc4, 0x42, 0x52, 0xf9, 0x05, 0x74, 0xd6, 0x18, 1649 | 0xa8, 0x01, 0xb5, 0xdf, 0xd8, 0x3c, 0x29, 0x59, 0x3c, 0xb1, 0xe5, 0x58, 0xfd, 0xe9, 0x40, 0xae, 1650 | 0xb0, 0x1c, 0x1c, 0x1b, 0xb6, 0xad, 0x5e, 0x19, 0x13, 0x55, 0x7b, 0x27, 0x57, 0x95, 0x5f, 0xc2, 1651 | 0xd9, 0xa3, 0x95, 0xbc, 0xea, 0x1c, 0x69, 0xdd, 0x39, 0x7f, 0xad, 0xc1, 0xa9, 0x49, 0xf3, 0x6f, 1652 | 0xe3, 0xf4, 0x0f, 0x56, 0x42, 0x53, 0x92, 0xc7, 0xa9, 0x4d, 0xf3, 0x3c, 0x88, 0xee, 0x32, 0xf4, 1653 | 0x1a, 0x64, 0x32, 0x9b, 0xc5, 0xdf, 0xea, 0x24, 0x27, 0x38, 0x26, 0x61, 0x10, 0xdd, 0x09, 0xf1, 1654 | 0x0d, 0x3a, 0xba, 0x01, 0x14, 0x2f, 0xe4, 0x67, 0xd4, 0xcb, 0x59, 0xd0, 0x44, 0x76, 0x5c, 0x96, 1655 | 0xce, 0xd8, 0x61, 0xe8, 0xc2, 0xda, 0x90, 0xc4, 0x5b, 0xb4, 0x21, 0x17, 0x0e, 0xa3, 0x42, 0x83, 1656 | 0x4e, 0x33, 0x2f, 0x0d, 0x92, 0x3c, 0x4e, 0x45, 0xfb, 0xff, 0xe9, 0xa7, 0x4c, 0x98, 0x0f, 0x05, 1657 | 0xf1, 0xa6, 0xae, 0x2f, 0xff, 0x26, 0xc1, 0xe1, 0x06, 0x90, 0xbd, 0xc9, 0x93, 0xd1, 0xd8, 0xe4, 1658 | 0x57, 0xef, 0x60, 0xbe, 0x46, 0x2e, 0xb4, 0x84, 0x38, 0xeb, 0x20, 0xe2, 0x9e, 0xbf, 0xfe, 0xec, 1659 | 0x43, 0x94, 0x14, 0xfe, 0x76, 0xae, 0x6a, 0x54, 0x5e, 0x40, 0x6b, 0x85, 0xc7, 0xaa, 0xe4, 0xca, 1660 | 0x1e, 0xcb, 0x5f, 0xa0, 0x26, 0xec, 0x4d, 0x1d, 0xac, 0x9a, 0x72, 0x45, 0xf1, 0x00, 0x6d, 0x3a, 1661 | 0x8e, 0xf5, 0x2f, 0x75, 0xea, 0x58, 0x63, 0x95, 0xf5, 0xab, 0x2f, 0x58, 0x55, 0x8d, 0x55, 0x73, 1662 | 0xaa, 0x8e, 0x64, 0x89, 0xf7, 0x32, 0x03, 0x1b, 0x57, 0x43, 0xdb, 0x31, 0xb0, 0x5c, 0xe1, 0x63, 1663 | 0x80, 0xe1, 0xb8, 0x96, 0x39, 0x7a, 0x2f, 0x57, 0xd9, 0x04, 0x53, 0x20, 0xdd, 0xa5, 0x7c, 0x4d, 1664 | 0xf9, 0x1a, 0x8e, 0xca, 0x53, 0x93, 0x9c, 0x2c, 0x52, 0x43, 0x86, 0xaa, 0x3a, 0x29, 0x5c, 0xd2, 1665 | 0xc4, 0x6c, 0xa9, 0xbc, 0x81, 0x27, 0x36, 0x4d, 0x3f, 0xd2, 0x54, 0x8b, 0xa3, 0x88, 0x7a, 0xf9, 1666 | 0x02, 0x8a, 0xa0, 0xf6, 0x21, 0x16, 0xdd, 0xa5, 0x89, 0xf9, 0x9a, 0xd1, 0x92, 0x38, 0xcd, 0xc5, 1667 | 0xe0, 0xc3, 0xd7, 0xca, 0x5f, 0x2a, 0xf0, 0x74, 0xe7, 0x23, 0x81, 0xde, 0xc3, 0x69, 0xb4, 0xdd, 1668 | 0xab, 0xa2, 0x6d, 0x7d, 0xf5, 0x09, 0xe7, 0xe3, 0x5d, 0xf2, 0x68, 0x0c, 0x47, 0xd1, 0xe6, 0x15, 1669 | 0xc5, 0xb8, 0xf2, 0xec, 0x81, 0xda, 0x55, 0x08, 0xde, 0x26, 0x87, 0x6c, 0x78, 0x92, 0x6d, 0x73, 1670 | 0x84, 0xc8, 0xd4, 0xb3, 0xc5, 0x00, 0xbe, 0x0d, 0x84, 0xb7, 0xcb, 0x2a, 0x3f, 0x87, 0xd3, 0x1d, 1671 | 0xef, 0x1b, 0x7a, 0x06, 0xcd, 0x79, 0x14, 0x7c, 0xe7, 0xb2, 0x69, 0x56, 0xe4, 0x68, 0x83, 0x11, 1672 | 0x9c, 0x20, 0xa4, 0x4a, 0x0e, 0x07, 0x0f, 0x46, 0xe3, 0xcf, 0x9f, 0xe6, 0x7a, 0x50, 0x5f, 0xfd, 1673 | 0x7b, 0x34, 0x71, 0xb9, 0x65, 0x6d, 0x32, 0xcb, 0x49, 0x3e, 0x2f, 0xee, 0xd6, 0xc0, 0x62, 0xa7, 1674 | 0xfc, 0xbb, 0x02, 0x87, 0x1b, 0xaf, 0xc7, 0x96, 0x36, 0x7b, 0x06, 0x20, 0x54, 0xb9, 0x8b, 0x29, 1675 | 0xb8, 0x29, 0x28, 0x43, 0x3e, 0x0c, 0xb3, 0xd1, 0x80, 0x2b, 0xef, 0x60, 0xbe, 0x66, 0x4a, 0x92, 1676 | 0xa0, 0x98, 0xc5, 0x3a, 0x98, 0x2d, 0xd9, 0xf1, 0xc4, 0x38, 0xc4, 0x67, 0xa7, 0x36, 0x2e, 0xb7, 1677 | 0xe8, 0xc7, 0x80, 0xc2, 0xf9, 0x2c, 0x0f, 0xd8, 0x2f, 0xa8, 0xfc, 0x38, 0x64, 0x7c, 0x04, 0x6a, 1678 | 0xe0, 0xc3, 0x92, 0x53, 0xfa, 0x25, 0x63, 0x5f, 0x84, 0x5b, 0xfe, 0xc0, 0x45, 0xde, 0x3d, 0x9f, 1679 | 0x5e, 0x24, 0xbc, 0x24, 0xb0, 0xc3, 0x44, 0x24, 0xa4, 0x7c, 0xea, 0x68, 0x62, 0xbe, 0x46, 0x6f, 1680 | 0xa1, 0xed, 0x53, 0x2f, 0xf6, 0xa9, 0xef, 0x72, 0x97, 0x36, 0xb9, 0x4b, 0x5f, 0xee, 0x7c, 0x40, 1681 | 0x2f, 0xf4, 0x02, 0x5d, 0x94, 0xbb, 0xbf, 0xdc, 0xb0, 0x72, 0x5f, 0xe1, 0xb1, 0xce, 0x6f, 0x5a, 1682 | 0xa6, 0x21, 0x4b, 0x6c, 0xc5, 0x26, 0x04, 0xb9, 0xa2, 0xfc, 0x57, 0x02, 0xb4, 0xf9, 0xe3, 0xfa, 1683 | 0x1e, 0xbd, 0x9a, 0xcd, 0x3d, 0x8f, 0x66, 0x19, 0xf7, 0x6a, 0x03, 0x97, 0x5b, 0xf4, 0x33, 0x38, 1684 | 0x89, 0xe8, 0x1d, 0xc9, 0x83, 0x8f, 0x4b, 0xaf, 0xba, 0xec, 0xe8, 0xdc, 0xb3, 0x1d, 0x7c, 0x5c, 1685 | 0x72, 0xcb, 0x23, 0x6a, 0xcc, 0xc2, 0x4a, 0x94, 0xea, 0xeb, 0x51, 0x3a, 0x86, 0xbd, 0x8f, 0x64, 1686 | 0x36, 0x2f, 0x3c, 0x2b, 0xe1, 0x62, 0xa3, 0xfc, 0x4b, 0x82, 0xb6, 0x7e, 0x1f, 0x91, 0x30, 0xf0, 1687 | 0x06, 0x01, 0x9d, 0xb1, 0x60, 0xae, 0xa6, 0xed, 0x72, 0x48, 0x59, 0xc1, 0xac, 0x26, 0xed, 0x0b, 1688 | 0x68, 0x67, 0x79, 0x1a, 0x44, 0x77, 0x6e, 0xa1, 0xbc, 0xc8, 0xdc, 0x56, 0x41, 0xbb, 0x66, 0x24, 1689 | 0xf4, 0x43, 0xe8, 0x44, 0xf3, 0x90, 0xa6, 0x81, 0x27, 0x30, 0x55, 0x7e, 0x80, 0xb6, 0x20, 0x2e, 1690 | 0x40, 0x37, 0x71, 0x3c, 0xa3, 0x24, 0x12, 0xa0, 0x1a, 0xf7, 0x46, 0x5b, 0x10, 0x39, 0x48, 0x79, 1691 | 0x29, 0x06, 0x49, 0xf6, 0x6b, 0x74, 0xf0, 0xd0, 0xbc, 0x92, 0x25, 0xd6, 0xb1, 0xcd, 0xe9, 0x58, 1692 | 0xae, 0xb0, 0x08, 0xf6, 0x2d, 0x6b, 0x24, 0x57, 0x95, 0x3f, 0x41, 0x67, 0xed, 0xd7, 0xbd, 0xc8, 1693 | 0x29, 0x69, 0x25, 0xa7, 0x5e, 0x97, 0xee, 0x28, 0xfa, 0xcf, 0xf1, 0xb6, 0x8b, 0x0a, 0x27, 0x31, 1694 | 0x2c, 0xfd, 0x48, 0xa3, 0xf2, 0x0f, 0xb4, 0x03, 0xcb, 0x21, 0xfd, 0xe7, 0x00, 0x5e, 0x1c, 0x0a, 1695 | 0x44, 0xbf, 0xdb, 0x0f, 0x22, 0x92, 0xde, 0x8b, 0x83, 0x64, 0xff, 0x0f, 0x00, 0x00, 0xff, 0xff, 1696 | 0x0b, 0x8b, 0x87, 0xcf, 0xbe, 0x10, 0x00, 0x00, 1697 | } 1698 | --------------------------------------------------------------------------------