exceeddata-sdk-vdata 2.10.5.1__tar.gz → 2.10.6__tar.gz
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- {exceeddata_sdk_vdata-2.10.5.1 → exceeddata_sdk_vdata-2.10.6}/PKG-INFO +1 -1
- {exceeddata_sdk_vdata-2.10.5.1 → exceeddata_sdk_vdata-2.10.6}/exceeddata/sdk/__init__.py +1 -1
- exceeddata_sdk_vdata-2.10.6/exceeddata/sdk/converter.py +632 -0
- {exceeddata_sdk_vdata-2.10.5.1 → exceeddata_sdk_vdata-2.10.6}/exceeddata/sdk/vdata.py +1 -1
- {exceeddata_sdk_vdata-2.10.5.1 → exceeddata_sdk_vdata-2.10.6}/exceeddata_sdk_vdata.egg-info/PKG-INFO +1 -1
- {exceeddata_sdk_vdata-2.10.5.1 → exceeddata_sdk_vdata-2.10.6}/setup.py +1 -1
- exceeddata_sdk_vdata-2.10.5.1/exceeddata/sdk/converter.py +0 -185
- {exceeddata_sdk_vdata-2.10.5.1 → exceeddata_sdk_vdata-2.10.6}/LICENSE +0 -0
- {exceeddata_sdk_vdata-2.10.5.1 → exceeddata_sdk_vdata-2.10.6}/README.rst +0 -0
- {exceeddata_sdk_vdata-2.10.5.1 → exceeddata_sdk_vdata-2.10.6}/exceeddata/sdk/blf.py +0 -0
- {exceeddata_sdk_vdata-2.10.5.1 → exceeddata_sdk_vdata-2.10.6}/exceeddata_sdk_vdata.egg-info/SOURCES.txt +0 -0
- {exceeddata_sdk_vdata-2.10.5.1 → exceeddata_sdk_vdata-2.10.6}/exceeddata_sdk_vdata.egg-info/dependency_links.txt +0 -0
- {exceeddata_sdk_vdata-2.10.5.1 → exceeddata_sdk_vdata-2.10.6}/exceeddata_sdk_vdata.egg-info/not-zip-safe +0 -0
- {exceeddata_sdk_vdata-2.10.5.1 → exceeddata_sdk_vdata-2.10.6}/exceeddata_sdk_vdata.egg-info/requires.txt +0 -0
- {exceeddata_sdk_vdata-2.10.5.1 → exceeddata_sdk_vdata-2.10.6}/exceeddata_sdk_vdata.egg-info/top_level.txt +0 -0
- {exceeddata_sdk_vdata-2.10.5.1 → exceeddata_sdk_vdata-2.10.6}/setup.cfg +0 -0
|
@@ -0,0 +1,632 @@
|
|
|
1
|
+
from .vdata import VDataReaderFactory, VDataReader, VDataByteReader
|
|
2
|
+
|
|
3
|
+
from datetime import datetime
|
|
4
|
+
from can import Message, ASCWriter
|
|
5
|
+
from .blf import BLFWriter
|
|
6
|
+
import json
|
|
7
|
+
import logging
|
|
8
|
+
import math
|
|
9
|
+
import struct
|
|
10
|
+
from typing import BinaryIO, List, Optional
|
|
11
|
+
|
|
12
|
+
logger = logging.getLogger(__name__)
|
|
13
|
+
|
|
14
|
+
def colParser(col):
|
|
15
|
+
arr = col.split("_")
|
|
16
|
+
if (len(arr)!= 2):
|
|
17
|
+
return 0,0
|
|
18
|
+
else:
|
|
19
|
+
return int(arr[0]), int (arr[1],base=16)
|
|
20
|
+
|
|
21
|
+
class VswToBlfConverter:
|
|
22
|
+
'''
|
|
23
|
+
A seekable reader class for wrapping around byte array when data file has already been
|
|
24
|
+
read into byte array.
|
|
25
|
+
'''
|
|
26
|
+
def __init__(self, inputPaths, outputFilename, signals=[]):
|
|
27
|
+
self._seekables = []
|
|
28
|
+
for fname in inputPaths:
|
|
29
|
+
inFile = open(fname, "rb")
|
|
30
|
+
data = inFile.read()
|
|
31
|
+
self._seekables.append(VDataByteReader( data))
|
|
32
|
+
self._outputFilename = outputFilename
|
|
33
|
+
self._signals = signals
|
|
34
|
+
self._deletedKeyFormat = None
|
|
35
|
+
self._signal_queue_mode = None
|
|
36
|
+
self._query_filter = True
|
|
37
|
+
self._read_living_data = True
|
|
38
|
+
|
|
39
|
+
def setSignals(self, signals):
|
|
40
|
+
'''
|
|
41
|
+
Override signal selection (same type as constructor ``signals``: list of names/prefixes).
|
|
42
|
+
'''
|
|
43
|
+
self._signals = signals
|
|
44
|
+
|
|
45
|
+
def setDeletedKeyFormat(self, deletedKeyFormat):
|
|
46
|
+
'''
|
|
47
|
+
:param deletedKeyFormat: deletedkey format for 64k page
|
|
48
|
+
:return:
|
|
49
|
+
'''
|
|
50
|
+
self._deletedKeyFormat = deletedKeyFormat
|
|
51
|
+
|
|
52
|
+
def setSignalQueueMode(self, mode):
|
|
53
|
+
'''
|
|
54
|
+
Set signal queue mode on the underlying VDataReaderFactory ('last', 'first', 'all').
|
|
55
|
+
'''
|
|
56
|
+
self._signal_queue_mode = mode
|
|
57
|
+
|
|
58
|
+
def setQueryFilter(self, query_filter):
|
|
59
|
+
'''
|
|
60
|
+
Set whether to apply query start-end time filter on the underlying VDataReaderFactory (default True).
|
|
61
|
+
'''
|
|
62
|
+
self._query_filter = query_filter
|
|
63
|
+
|
|
64
|
+
def setReadLivingData(self, read_living_data):
|
|
65
|
+
'''
|
|
66
|
+
Set whether to read living (non-finalized) buckets on the underlying VDataReaderFactory (default True).
|
|
67
|
+
'''
|
|
68
|
+
self._read_living_data = read_living_data
|
|
69
|
+
|
|
70
|
+
def convert(self, colParserFun=colParser ):
|
|
71
|
+
factory = VDataReaderFactory()
|
|
72
|
+
factory.setDataReaders(self._seekables)
|
|
73
|
+
factory.setSignals(signals=self._signals)
|
|
74
|
+
if self._deletedKeyFormat is not None:
|
|
75
|
+
factory.setDeletedKeyFormat(self._deletedKeyFormat)
|
|
76
|
+
if self._signal_queue_mode is not None:
|
|
77
|
+
factory.setSignalQueueMode(self._signal_queue_mode)
|
|
78
|
+
factory.setQueryFilter(self._query_filter)
|
|
79
|
+
factory.setReadLivingData(self._read_living_data)
|
|
80
|
+
reader = factory.open()
|
|
81
|
+
vdf = reader.df()
|
|
82
|
+
#print(vdf.cols)
|
|
83
|
+
#store the coloumn index to channel_id, message_id tuple mapping.
|
|
84
|
+
#这里用来保留信号列与channel_id, message_id之间的对应关系,第一列总是为时间,所以会少一列
|
|
85
|
+
can_info= []
|
|
86
|
+
for signal in vdf.cols():
|
|
87
|
+
channel_id, message_id, frame_type = colParserFun(signal)
|
|
88
|
+
|
|
89
|
+
can_info.append([channel_id,message_id, frame_type])
|
|
90
|
+
#if (len(arr)!= 2):
|
|
91
|
+
# can_info.append(None)
|
|
92
|
+
#else:
|
|
93
|
+
#You can customize here for you own column name format.
|
|
94
|
+
#这里需要做容错的处理,如果信号中有下划线,但不是数值就会出错。
|
|
95
|
+
# channel_id =int(arr[0])
|
|
96
|
+
# message_id = int (arr[1],base=16)
|
|
97
|
+
|
|
98
|
+
|
|
99
|
+
|
|
100
|
+
current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
|
|
101
|
+
print(" " + current_time)
|
|
102
|
+
blfwriter = BLFWriter(self._outputFilename)
|
|
103
|
+
|
|
104
|
+
|
|
105
|
+
#itorator for each row and data column.
|
|
106
|
+
#遍历解出来的每一行数据
|
|
107
|
+
for row in vdf.objects():
|
|
108
|
+
if blfwriter.start_timestamp == None :
|
|
109
|
+
blfwriter.start_timestamp = row[0]//1000
|
|
110
|
+
#第一列是时间,所以从第二列信号数据开始分析
|
|
111
|
+
#time for first column, so we start from the second column.
|
|
112
|
+
for i in range (1, len(row)):
|
|
113
|
+
#store the signal byte array for not null column data.
|
|
114
|
+
#如果信号非空,则生成相应的数据
|
|
115
|
+
if row[i] != None and isinstance (row[i], list) and can_info[i-1][0]!=-1:
|
|
116
|
+
msg = Message(timestamp=row[0]/1000.0, channel=can_info[i-1][0] -1 ,arbitration_id=can_info[i-1][1],data= row[i], is_fd=True, is_extended_id = False)
|
|
117
|
+
frame_type = 0
|
|
118
|
+
if (can_info[i-1][2] ==2 ):
|
|
119
|
+
frame_type = 11 #LIN_MESSAGE_TYPE in blf
|
|
120
|
+
#写入BLF文件
|
|
121
|
+
blfwriter.on_message_received(msg, frame_type)
|
|
122
|
+
|
|
123
|
+
elif row[i] != None and isinstance(row[i], (bytes, bytearray)) and can_info[i - 1][0] != -1:
|
|
124
|
+
# if length > 64, skip
|
|
125
|
+
if len(row[i]) > 64:
|
|
126
|
+
continue
|
|
127
|
+
msg = Message(timestamp=row[0] / 1000.0, channel=can_info[i - 1][0] - 1,
|
|
128
|
+
arbitration_id=can_info[i - 1][1], data=row[i], is_fd=True, is_extended_id=False)
|
|
129
|
+
frame_type = 0
|
|
130
|
+
if (can_info[i - 1][2] == 2):
|
|
131
|
+
frame_type = 11 # LIN_MESSAGE_TYPE in blf
|
|
132
|
+
# 写入BLF文件
|
|
133
|
+
blfwriter.on_message_received(msg, frame_type)
|
|
134
|
+
|
|
135
|
+
|
|
136
|
+
elif row[i] != None and can_info[i-1][0]!=-1:
|
|
137
|
+
data=[1]
|
|
138
|
+
data[0] =row[i]
|
|
139
|
+
msg = Message(timestamp=row[0]/1000.0, channel=can_info[i-1][0] -1 ,arbitration_id=can_info[i-1][1],data= data, is_fd=True, is_extended_id = False)
|
|
140
|
+
#写入BLF文件
|
|
141
|
+
blfwriter.on_message_received(msg)
|
|
142
|
+
|
|
143
|
+
#finalize the BLF file and flush to disk
|
|
144
|
+
#将BLF文件终结,写入磁盘
|
|
145
|
+
blfwriter.stop()
|
|
146
|
+
|
|
147
|
+
class VswToAscConverter:
|
|
148
|
+
'''
|
|
149
|
+
A seekable reader class for wrapping around byte array when data file has already been
|
|
150
|
+
read into byte array.
|
|
151
|
+
'''
|
|
152
|
+
def __init__(self, inputPaths, outputFilename, signals=[]):
|
|
153
|
+
self._seekables = []
|
|
154
|
+
for fname in inputPaths:
|
|
155
|
+
inFile = open(fname, "rb")
|
|
156
|
+
data = inFile.read()
|
|
157
|
+
self._seekables.append(VDataByteReader( data))
|
|
158
|
+
self._outputFilename = outputFilename
|
|
159
|
+
self._signals = signals
|
|
160
|
+
self._deletedKeyFormat = None
|
|
161
|
+
self._signal_queue_mode = None
|
|
162
|
+
self._query_filter = True
|
|
163
|
+
self._read_living_data = True
|
|
164
|
+
|
|
165
|
+
def setSignals(self, signals):
|
|
166
|
+
'''
|
|
167
|
+
Override signal selection (same type as constructor ``signals``: list of names/prefixes).
|
|
168
|
+
'''
|
|
169
|
+
self._signals = signals
|
|
170
|
+
|
|
171
|
+
def setDeletedKeyFormat(self, deletedKeyFormat):
|
|
172
|
+
'''
|
|
173
|
+
:param deletedKeyFormat: deletedkey format for 64k page
|
|
174
|
+
:return:
|
|
175
|
+
'''
|
|
176
|
+
self._deletedKeyFormat = deletedKeyFormat
|
|
177
|
+
|
|
178
|
+
def setSignalQueueMode(self, mode):
|
|
179
|
+
'''
|
|
180
|
+
Set signal queue mode on the underlying VDataReaderFactory ('last', 'first', 'all').
|
|
181
|
+
'''
|
|
182
|
+
self._signal_queue_mode = mode
|
|
183
|
+
|
|
184
|
+
def setQueryFilter(self, query_filter):
|
|
185
|
+
'''
|
|
186
|
+
Set whether to apply query start-end time filter on the underlying VDataReaderFactory (default True).
|
|
187
|
+
'''
|
|
188
|
+
self._query_filter = query_filter
|
|
189
|
+
|
|
190
|
+
def setReadLivingData(self, read_living_data):
|
|
191
|
+
'''
|
|
192
|
+
Set whether to read living (non-finalized) buckets on the underlying VDataReaderFactory (default True).
|
|
193
|
+
'''
|
|
194
|
+
self._read_living_data = read_living_data
|
|
195
|
+
|
|
196
|
+
def convert(self, colParserFun=colParser):
|
|
197
|
+
factory = VDataReaderFactory()
|
|
198
|
+
factory.setDataReaders(self._seekables)
|
|
199
|
+
factory.setSignals(signals=self._signals)
|
|
200
|
+
if self._deletedKeyFormat is not None:
|
|
201
|
+
factory.setDeletedKeyFormat(self._deletedKeyFormat)
|
|
202
|
+
if self._signal_queue_mode is not None:
|
|
203
|
+
factory.setSignalQueueMode(self._signal_queue_mode)
|
|
204
|
+
factory.setQueryFilter(self._query_filter)
|
|
205
|
+
factory.setReadLivingData(self._read_living_data)
|
|
206
|
+
reader = factory.open()
|
|
207
|
+
vdf = reader.df()
|
|
208
|
+
#print(vdf.cols)
|
|
209
|
+
#store the coloumn index to channel_id, message_id tuple mapping.
|
|
210
|
+
#这里用来保留信号列与channel_id, message_id之间的对应关系,第一列总是为时间,所以会少一列
|
|
211
|
+
can_info= []
|
|
212
|
+
cols = vdf.cols()
|
|
213
|
+
for signal in vdf.cols():
|
|
214
|
+
channel_id, message_id, frame_type = colParserFun(signal)
|
|
215
|
+
if frame_type!=2:
|
|
216
|
+
can_info.append([channel_id,message_id&0x7fffffff, message_id&0x8000000 != 0])
|
|
217
|
+
else:
|
|
218
|
+
can_info.append([-1,-1, -1])
|
|
219
|
+
|
|
220
|
+
|
|
221
|
+
current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
|
|
222
|
+
print(" " + current_time)
|
|
223
|
+
writer = ASCWriter(self._outputFilename)
|
|
224
|
+
|
|
225
|
+
#itorator for each row and data column.
|
|
226
|
+
#遍历解出来的每一行数据
|
|
227
|
+
for row in vdf.objects():
|
|
228
|
+
#第一列是时间,所以从第二列信号数据开始分析
|
|
229
|
+
#time for first column, so we start from the second column.
|
|
230
|
+
for i in range (1, len(row)):
|
|
231
|
+
#store the signal byte array for not null column data.
|
|
232
|
+
#如果信号非空,则生成相应的数据
|
|
233
|
+
if row[i] is not None and isinstance(row[i], (list)) and can_info[i - 1][0]!=-1:
|
|
234
|
+
msg = Message(timestamp=row[0]/1000.0, channel=can_info[i-1][0]-1,arbitration_id=can_info[i-1][1],data= row[i], is_fd=True, is_extended_id =can_info[i-1][2])
|
|
235
|
+
#写入ASC文件
|
|
236
|
+
writer.on_message_received(msg)
|
|
237
|
+
elif row[i] is not None and isinstance(row[i], (bytes, bytearray)) and can_info[i - 1][0]!=-1:
|
|
238
|
+
# if length > 64, skip
|
|
239
|
+
if len(row[i]) > 64:
|
|
240
|
+
continue
|
|
241
|
+
msg = Message(timestamp=row[0]/1000.0, channel=can_info[i-1][0]-1,arbitration_id=can_info[i-1][1],data= row[i], is_fd=True, is_extended_id =can_info[i-1][2])
|
|
242
|
+
#写入ASC文件
|
|
243
|
+
writer.on_message_received(msg)
|
|
244
|
+
elif row[i] is not None and can_info[i - 1][0]!=-1:
|
|
245
|
+
data=[1]
|
|
246
|
+
data[0] =row[i]
|
|
247
|
+
msg = Message(timestamp=row[0]/1000.0, channel=can_info[i-1][0] -1 ,arbitration_id=can_info[i-1][1],data= data, is_fd=True, is_extended_id = can_info[i-1][2])
|
|
248
|
+
#写入ASC文件
|
|
249
|
+
writer.on_message_received(msg)
|
|
250
|
+
|
|
251
|
+
#finalize the ASC file and flush to disk
|
|
252
|
+
#将ASC文件终结,写入磁盘
|
|
253
|
+
writer.stop()
|
|
254
|
+
|
|
255
|
+
|
|
256
|
+
def _vsw_event_id_from_bytes(data: bytes) -> int:
|
|
257
|
+
"""Parse extended-info event id (int64 LE) from raw VSW bytes; 0 if invalid."""
|
|
258
|
+
if data is None or len(data) < 8:
|
|
259
|
+
return 0
|
|
260
|
+
offset = 0
|
|
261
|
+
b8 = data[offset : offset + 8]
|
|
262
|
+
offset += 8
|
|
263
|
+
if len(b8) < 8:
|
|
264
|
+
return 0
|
|
265
|
+
format_version = b8[3] & 0xFF
|
|
266
|
+
extlength = 0
|
|
267
|
+
if format_version > 0:
|
|
268
|
+
if format_version < 26:
|
|
269
|
+
offset += 16
|
|
270
|
+
else:
|
|
271
|
+
offset += 32
|
|
272
|
+
if offset + 8 > len(data):
|
|
273
|
+
return 0
|
|
274
|
+
storebytes = data[offset : offset + 8]
|
|
275
|
+
offset += 8
|
|
276
|
+
extlength = struct.unpack_from("<H", storebytes, 0)[0]
|
|
277
|
+
if extlength <= 0 or offset + extlength > len(data):
|
|
278
|
+
return 0
|
|
279
|
+
extended = data[offset : offset + extlength]
|
|
280
|
+
if len(extended) < 8:
|
|
281
|
+
return 0
|
|
282
|
+
return struct.unpack_from("<q", extended, 0)[0]
|
|
283
|
+
|
|
284
|
+
|
|
285
|
+
def _ipv4_header_checksum(header20: bytes) -> int:
|
|
286
|
+
"""RFC 791 checksum for a 20-byte IPv4 header (checksum field must be zero in input)."""
|
|
287
|
+
if len(header20) != 20:
|
|
288
|
+
raise ValueError("IPv4 header must be 20 bytes")
|
|
289
|
+
s = 0
|
|
290
|
+
for i in range(0, 20, 2):
|
|
291
|
+
word = 0 if i == 10 else (header20[i] << 8) | header20[i + 1]
|
|
292
|
+
s += word
|
|
293
|
+
while s >> 16:
|
|
294
|
+
s = (s & 0xFFFF) + (s >> 16)
|
|
295
|
+
return (~s) & 0xFFFF
|
|
296
|
+
|
|
297
|
+
|
|
298
|
+
class VswToPcapConverter:
|
|
299
|
+
"""
|
|
300
|
+
Convert VSW rows with SOME/IP STF byte columns into a PCAP (Ethernet + 802.1Q + IPv4 + UDP).
|
|
301
|
+
Only inputs whose extended event id is 100 or 101 are accepted (same rules as the Java converter).
|
|
302
|
+
Transport is UDP only (no TCP branch).
|
|
303
|
+
"""
|
|
304
|
+
|
|
305
|
+
def __init__(self, inputPaths, outputFilename, jsonPath, signals=[]):
|
|
306
|
+
self._inputs = []
|
|
307
|
+
for fname in inputPaths:
|
|
308
|
+
with open(fname, "rb") as f:
|
|
309
|
+
self._inputs.append(f.read())
|
|
310
|
+
self._outputFilename = outputFilename
|
|
311
|
+
self._jsonPath = jsonPath
|
|
312
|
+
self._json_encoding = "utf-8"
|
|
313
|
+
self._signals = signals
|
|
314
|
+
self._query_filter = True
|
|
315
|
+
self._read_living_data = True
|
|
316
|
+
self._signal_queue_mode = None
|
|
317
|
+
|
|
318
|
+
def setSignals(self, signals):
|
|
319
|
+
"""
|
|
320
|
+
Override signal selection (same type as constructor ``signals``: list of names/prefixes).
|
|
321
|
+
"""
|
|
322
|
+
self._signals = signals
|
|
323
|
+
|
|
324
|
+
def set_json_path(self, json_path, encoding="utf-8"):
|
|
325
|
+
"""
|
|
326
|
+
Override matrix JSON path (and optional encoding) used in ``convert()``.
|
|
327
|
+
"""
|
|
328
|
+
self._jsonPath = json_path
|
|
329
|
+
self._json_encoding = encoding
|
|
330
|
+
|
|
331
|
+
def setSignalQueueMode(self, mode):
|
|
332
|
+
"""
|
|
333
|
+
Set signal queue mode on the underlying VDataReaderFactory ('last', 'first', 'all').
|
|
334
|
+
"""
|
|
335
|
+
self._signal_queue_mode = mode
|
|
336
|
+
|
|
337
|
+
def setReadLivingData(self, read_living_data):
|
|
338
|
+
self._read_living_data = read_living_data
|
|
339
|
+
|
|
340
|
+
def setQueryFilter(self, query_filter):
|
|
341
|
+
self._query_filter = query_filter
|
|
342
|
+
|
|
343
|
+
@staticmethod
|
|
344
|
+
def _all_same_event_id(ids: List[int]) -> bool:
|
|
345
|
+
if not ids:
|
|
346
|
+
return True
|
|
347
|
+
v = ids[0]
|
|
348
|
+
return all(x == v for x in ids)
|
|
349
|
+
|
|
350
|
+
@staticmethod
|
|
351
|
+
def _hex_to_bytes(hex_str: str) -> bytes:
|
|
352
|
+
h = hex_str.replace("0x", "").replace("0X", "")
|
|
353
|
+
if len(h) % 2:
|
|
354
|
+
raise ValueError("hex string length must be even")
|
|
355
|
+
return bytes(int(h[i : i + 2], 16) for i in range(0, len(h), 2))
|
|
356
|
+
|
|
357
|
+
@staticmethod
|
|
358
|
+
def _ip_to_bytes(ip_str: str) -> bytes:
|
|
359
|
+
parts = ip_str.split(".")
|
|
360
|
+
if len(parts) != 4:
|
|
361
|
+
raise ValueError("invalid IPv4 address")
|
|
362
|
+
return bytes(int(p) & 0xFF for p in parts)
|
|
363
|
+
|
|
364
|
+
def _write_global_header(self, os: BinaryIO):
|
|
365
|
+
# magic, major, minor, thiszone, sigfigs, snaplen, network (Ethernet)
|
|
366
|
+
hdr = struct.pack("<IHHIIII", 0xA1B2C3D4, 2, 4, 0, 0, 65535, 1)
|
|
367
|
+
os.write(hdr)
|
|
368
|
+
|
|
369
|
+
def _write_packet(self, os: BinaryIO, packet: bytes, timestamp_ms: int):
|
|
370
|
+
sec = timestamp_ms // 1000
|
|
371
|
+
usec = (timestamp_ms % 1000) * 1000
|
|
372
|
+
plen = len(packet)
|
|
373
|
+
os.write(struct.pack("<IIII", sec & 0xFFFFFFFF, usec & 0xFFFFFFFF, plen, plen))
|
|
374
|
+
os.write(packet)
|
|
375
|
+
|
|
376
|
+
def _build_someip(
|
|
377
|
+
self,
|
|
378
|
+
service_id: bytes,
|
|
379
|
+
method_id: bytes,
|
|
380
|
+
payload: Optional[bytes],
|
|
381
|
+
client_id: int,
|
|
382
|
+
session_id: int,
|
|
383
|
+
stf_interface_version: int,
|
|
384
|
+
message_type: int,
|
|
385
|
+
return_code: int,
|
|
386
|
+
) -> bytes:
|
|
387
|
+
payload = payload or b""
|
|
388
|
+
payload_length = len(payload)
|
|
389
|
+
someip_length = payload_length + 8
|
|
390
|
+
buf = bytearray()
|
|
391
|
+
buf.extend(service_id)
|
|
392
|
+
buf.extend(method_id)
|
|
393
|
+
buf += struct.pack(">I", someip_length)
|
|
394
|
+
buf += struct.pack(">h", client_id)
|
|
395
|
+
buf += struct.pack(">h", session_id)
|
|
396
|
+
buf.append(1)
|
|
397
|
+
buf.append(stf_interface_version & 0xFF if stf_interface_version >= 0 else 0xFF)
|
|
398
|
+
buf.append(message_type & 0xFF)
|
|
399
|
+
buf.append(return_code & 0xFF)
|
|
400
|
+
buf.extend(payload)
|
|
401
|
+
return bytes(buf)
|
|
402
|
+
|
|
403
|
+
def _build_ether_ip_udp(
|
|
404
|
+
self,
|
|
405
|
+
data_obj: dict,
|
|
406
|
+
check_sum_net: int,
|
|
407
|
+
udp_payload: bytes,
|
|
408
|
+
udp_src_port: int,
|
|
409
|
+
) -> bytes:
|
|
410
|
+
data_length = 8 + len(udp_payload)
|
|
411
|
+
ip_length = 20 + data_length
|
|
412
|
+
ether_vlan_ip = 12 + 6
|
|
413
|
+
buf = bytearray(ether_vlan_ip + ip_length)
|
|
414
|
+
pos = 0
|
|
415
|
+
# Ethernet + 802.1Q + IPv4 EtherType (matches Java placeholders)
|
|
416
|
+
buf[pos : pos + 6] = b"\xff\xff\xff\xff\xff\xff"
|
|
417
|
+
pos += 6
|
|
418
|
+
buf[pos : pos + 6] = b"\x02\x00\x00\x00\x00\x01"
|
|
419
|
+
pos += 6
|
|
420
|
+
buf[pos : pos + 6] = b"\x81\x00\xff\xef\x08\x00"
|
|
421
|
+
pos += 6
|
|
422
|
+
|
|
423
|
+
ip_header_offset = pos
|
|
424
|
+
buf[pos] = 0x45
|
|
425
|
+
buf[pos + 1] = 0x00
|
|
426
|
+
struct.pack_into(">H", buf, pos + 2, ip_length)
|
|
427
|
+
struct.pack_into(">H", buf, pos + 4, 0xFFFF)
|
|
428
|
+
struct.pack_into(">H", buf, pos + 6, 0x4000)
|
|
429
|
+
buf[pos + 8] = 0xFF
|
|
430
|
+
buf[pos + 9] = 17 # UDP
|
|
431
|
+
struct.pack_into(">H", buf, pos + 10, 0)
|
|
432
|
+
src_ip = self._ip_to_bytes(data_obj["srcAddr"])
|
|
433
|
+
dst_ip = self._ip_to_bytes(data_obj["dstAddr"])
|
|
434
|
+
buf[pos + 12 : pos + 16] = src_ip
|
|
435
|
+
buf[pos + 16 : pos + 20] = dst_ip
|
|
436
|
+
|
|
437
|
+
ip_hdr = bytes(buf[ip_header_offset : ip_header_offset + 20])
|
|
438
|
+
csum = _ipv4_header_checksum(ip_hdr)
|
|
439
|
+
struct.pack_into(">H", buf, ip_header_offset + 10, csum)
|
|
440
|
+
pos = ip_header_offset + 20
|
|
441
|
+
|
|
442
|
+
udp_src = udp_src_port if 0 <= udp_src_port <= 0xFFFF else 0xFFFF
|
|
443
|
+
struct.pack_into(">H", buf, pos, udp_src & 0xFFFF)
|
|
444
|
+
struct.pack_into(">H", buf, pos + 2, 0xFFFF)
|
|
445
|
+
struct.pack_into(">H", buf, pos + 4, data_length)
|
|
446
|
+
udp_csum = 0 if check_sum_net == 0 else (check_sum_net & 0xFFFF)
|
|
447
|
+
struct.pack_into(">H", buf, pos + 6, udp_csum)
|
|
448
|
+
pos += 8
|
|
449
|
+
buf[pos:] = udp_payload
|
|
450
|
+
return bytes(buf)
|
|
451
|
+
|
|
452
|
+
def _build_packet_from_line(
|
|
453
|
+
self,
|
|
454
|
+
check_sum_net: int,
|
|
455
|
+
client_id_net: int,
|
|
456
|
+
session_id_net: int,
|
|
457
|
+
message_type: int,
|
|
458
|
+
return_code: int,
|
|
459
|
+
payload: Optional[bytes],
|
|
460
|
+
data_obj: dict,
|
|
461
|
+
stf_interface_version: int,
|
|
462
|
+
stf_udp_src_port: int,
|
|
463
|
+
) -> Optional[bytes]:
|
|
464
|
+
try:
|
|
465
|
+
service_id = self._hex_to_bytes(data_obj["serviceId"])
|
|
466
|
+
method_id = self._hex_to_bytes(data_obj["methodId"])
|
|
467
|
+
if len(service_id) != 2 or len(method_id) != 2:
|
|
468
|
+
raise ValueError("serviceId and methodId must be 2 bytes each")
|
|
469
|
+
someip = self._build_someip(
|
|
470
|
+
service_id,
|
|
471
|
+
method_id,
|
|
472
|
+
payload,
|
|
473
|
+
client_id_net,
|
|
474
|
+
session_id_net,
|
|
475
|
+
stf_interface_version,
|
|
476
|
+
message_type,
|
|
477
|
+
return_code,
|
|
478
|
+
)
|
|
479
|
+
return self._build_ether_ip_udp(data_obj, check_sum_net, someip, stf_udp_src_port)
|
|
480
|
+
except Exception as e:
|
|
481
|
+
logger.error("Failed to parse application layer: %s", e)
|
|
482
|
+
return None
|
|
483
|
+
|
|
484
|
+
def convert(self) -> bool:
|
|
485
|
+
if not self._inputs:
|
|
486
|
+
logger.error("No input files specified")
|
|
487
|
+
return False
|
|
488
|
+
if not self._outputFilename:
|
|
489
|
+
logger.error("No output filename specified")
|
|
490
|
+
return False
|
|
491
|
+
if not self._jsonPath:
|
|
492
|
+
logger.error("No json path specified")
|
|
493
|
+
return False
|
|
494
|
+
|
|
495
|
+
try:
|
|
496
|
+
with open(self._jsonPath, "r", encoding=self._json_encoding) as jf:
|
|
497
|
+
root_obj = json.load(jf)
|
|
498
|
+
if not isinstance(root_obj, dict):
|
|
499
|
+
logger.error("JSON root must be an object")
|
|
500
|
+
return False
|
|
501
|
+
|
|
502
|
+
seekables = []
|
|
503
|
+
event_ids = []
|
|
504
|
+
for i, raw in enumerate(self._inputs):
|
|
505
|
+
eid = _vsw_event_id_from_bytes(raw)
|
|
506
|
+
if eid == 0:
|
|
507
|
+
logger.error("eventid is 0, skip the %d-th vsw input file", i)
|
|
508
|
+
elif eid not in (100, 101):
|
|
509
|
+
logger.error("eventid %s is not 100 or 101, skip the %d-th vsw input file", eid, i)
|
|
510
|
+
else:
|
|
511
|
+
seekables.append(VDataByteReader(raw))
|
|
512
|
+
event_ids.append(eid)
|
|
513
|
+
|
|
514
|
+
if not seekables:
|
|
515
|
+
logger.error("No input file with eventid 100 or 101; abort conversion")
|
|
516
|
+
return False
|
|
517
|
+
if not self._all_same_event_id(event_ids):
|
|
518
|
+
logger.error(
|
|
519
|
+
"Mixed eventid in batch (must be all 100 or all 101): %s; abort conversion",
|
|
520
|
+
event_ids,
|
|
521
|
+
)
|
|
522
|
+
return False
|
|
523
|
+
|
|
524
|
+
batch_event_id = event_ids[0]
|
|
525
|
+
check_sum_exist = batch_event_id == 101
|
|
526
|
+
|
|
527
|
+
factory = VDataReaderFactory()
|
|
528
|
+
factory.setDataReaders(seekables)
|
|
529
|
+
factory.setSignals(signals=self._signals)
|
|
530
|
+
factory.setQueryFilter(self._query_filter)
|
|
531
|
+
factory.setReadLivingData(self._read_living_data)
|
|
532
|
+
if self._signal_queue_mode is not None:
|
|
533
|
+
factory.setSignalQueueMode(self._signal_queue_mode)
|
|
534
|
+
|
|
535
|
+
reader = factory.open()
|
|
536
|
+
vdf = reader.df()
|
|
537
|
+
rows = vdf.objects()
|
|
538
|
+
if not rows:
|
|
539
|
+
return False
|
|
540
|
+
|
|
541
|
+
cols = vdf.cols()
|
|
542
|
+
with open(self._outputFilename, "wb") as out:
|
|
543
|
+
self._write_global_header(out)
|
|
544
|
+
for row in rows:
|
|
545
|
+
ts = row[0]
|
|
546
|
+
if hasattr(ts, "timestamp"):
|
|
547
|
+
timestamp_ms = int(ts.timestamp() * 1000)
|
|
548
|
+
else:
|
|
549
|
+
timestamp_ms = int(ts)
|
|
550
|
+
|
|
551
|
+
for col_idx in range(1, len(row)):
|
|
552
|
+
col_name = cols[col_idx - 1]
|
|
553
|
+
data_entry = root_obj.get(col_name)
|
|
554
|
+
if data_entry is None:
|
|
555
|
+
continue
|
|
556
|
+
if not isinstance(data_entry, dict):
|
|
557
|
+
continue
|
|
558
|
+
|
|
559
|
+
val = row[col_idx]
|
|
560
|
+
if isinstance(val, list):
|
|
561
|
+
val = bytes(val)
|
|
562
|
+
if not isinstance(val, (bytes, bytearray)):
|
|
563
|
+
continue
|
|
564
|
+
|
|
565
|
+
v = bytes(val)
|
|
566
|
+
ln = len(v)
|
|
567
|
+
if ln < 3:
|
|
568
|
+
logger.error(
|
|
569
|
+
"column '%s' byte[] too short for mandatory 3-byte prefix: len=%s, skip",
|
|
570
|
+
col_name,
|
|
571
|
+
ln,
|
|
572
|
+
)
|
|
573
|
+
continue
|
|
574
|
+
|
|
575
|
+
stf_interface_version = v[0] & 0xFF
|
|
576
|
+
stf_udp_src_port = ((v[1] & 0xFF) << 8) | (v[2] & 0xFF)
|
|
577
|
+
p = 3
|
|
578
|
+
check_sum_net = 0
|
|
579
|
+
client_id_net = 0
|
|
580
|
+
session_id_net = 0
|
|
581
|
+
message_type = 0
|
|
582
|
+
return_code = 0
|
|
583
|
+
payload: Optional[bytes] = None
|
|
584
|
+
|
|
585
|
+
if check_sum_exist:
|
|
586
|
+
if ln < 11:
|
|
587
|
+
logger.error(
|
|
588
|
+
"column '%s' event 101 byte[] too short: len=%s, skip",
|
|
589
|
+
col_name,
|
|
590
|
+
ln,
|
|
591
|
+
)
|
|
592
|
+
continue
|
|
593
|
+
check_sum_net = struct.unpack_from(">h", v, p)[0]
|
|
594
|
+
client_id_net = struct.unpack_from(">h", v, p + 2)[0]
|
|
595
|
+
session_id_net = struct.unpack_from(">h", v, p + 4)[0]
|
|
596
|
+
message_type = v[p + 6]
|
|
597
|
+
return_code = v[p + 7]
|
|
598
|
+
rest = ln - p - 8
|
|
599
|
+
payload = v[p + 8 : p + 8 + rest] if rest > 0 else None
|
|
600
|
+
else:
|
|
601
|
+
if ln < 9:
|
|
602
|
+
logger.error(
|
|
603
|
+
"column '%s' event 100 byte[] too short: len=%s, skip",
|
|
604
|
+
col_name,
|
|
605
|
+
ln,
|
|
606
|
+
)
|
|
607
|
+
continue
|
|
608
|
+
client_id_net = struct.unpack_from(">h", v, p)[0]
|
|
609
|
+
session_id_net = struct.unpack_from(">h", v, p + 2)[0]
|
|
610
|
+
message_type = v[p + 4]
|
|
611
|
+
return_code = v[p + 5]
|
|
612
|
+
rest = ln - p - 6
|
|
613
|
+
payload = v[p + 6 : p + 6 + rest] if rest > 0 else None
|
|
614
|
+
|
|
615
|
+
packet = self._build_packet_from_line(
|
|
616
|
+
check_sum_net,
|
|
617
|
+
client_id_net,
|
|
618
|
+
session_id_net,
|
|
619
|
+
message_type,
|
|
620
|
+
return_code,
|
|
621
|
+
payload,
|
|
622
|
+
data_entry,
|
|
623
|
+
stf_interface_version,
|
|
624
|
+
stf_udp_src_port,
|
|
625
|
+
)
|
|
626
|
+
if packet is not None:
|
|
627
|
+
self._write_packet(out, packet, timestamp_ms)
|
|
628
|
+
|
|
629
|
+
return True
|
|
630
|
+
except Exception as e:
|
|
631
|
+
logger.error("Error occurred during conversion: %s", e)
|
|
632
|
+
return False
|
|
@@ -1,185 +0,0 @@
|
|
|
1
|
-
from .vdata import VDataReaderFactory, VDataReader, VDataByteReader
|
|
2
|
-
|
|
3
|
-
from datetime import datetime
|
|
4
|
-
from can import Message, ASCWriter
|
|
5
|
-
from .blf import BLFWriter
|
|
6
|
-
import math
|
|
7
|
-
|
|
8
|
-
def colParser(col):
|
|
9
|
-
arr = col.split("_")
|
|
10
|
-
if (len(arr)!= 2):
|
|
11
|
-
return 0,0
|
|
12
|
-
else:
|
|
13
|
-
return int(arr[0]), int (arr[1],base=16)
|
|
14
|
-
|
|
15
|
-
class VswToBlfConverter:
|
|
16
|
-
'''
|
|
17
|
-
A seekable reader class for wrapping around byte array when data file has already been
|
|
18
|
-
read into byte array.
|
|
19
|
-
'''
|
|
20
|
-
def __init__(self, inputPaths, outputFilename, signals=[]):
|
|
21
|
-
self._seekables = []
|
|
22
|
-
for fname in inputPaths:
|
|
23
|
-
inFile = open(fname, "rb")
|
|
24
|
-
data = inFile.read()
|
|
25
|
-
self._seekables.append(VDataByteReader( data))
|
|
26
|
-
self._outputFilename = outputFilename
|
|
27
|
-
self._signals = signals
|
|
28
|
-
self._deletedKeyFormat = None
|
|
29
|
-
|
|
30
|
-
def setDeletedKeyFormat(self, deletedKeyFormat):
|
|
31
|
-
'''
|
|
32
|
-
:param deletedKeyFormat: deletedkey format for 64k page
|
|
33
|
-
:return:
|
|
34
|
-
'''
|
|
35
|
-
self._deletedKeyFormat = deletedKeyFormat
|
|
36
|
-
|
|
37
|
-
def convert(self, colParserFun=colParser ):
|
|
38
|
-
factory = VDataReaderFactory()
|
|
39
|
-
factory.setDataReaders(self._seekables)
|
|
40
|
-
factory.setSignals(signals=self._signals)
|
|
41
|
-
if self._deletedKeyFormat is not None:
|
|
42
|
-
factory.setDeletedKeyFormat(self._deletedKeyFormat)
|
|
43
|
-
reader = factory.open()
|
|
44
|
-
vdf = reader.df()
|
|
45
|
-
#print(vdf.cols)
|
|
46
|
-
#store the coloumn index to channel_id, message_id tuple mapping.
|
|
47
|
-
#这里用来保留信号列与channel_id, message_id之间的对应关系,第一列总是为时间,所以会少一列
|
|
48
|
-
can_info= []
|
|
49
|
-
for signal in vdf.cols():
|
|
50
|
-
channel_id, message_id, frame_type = colParserFun(signal)
|
|
51
|
-
|
|
52
|
-
can_info.append([channel_id,message_id, frame_type])
|
|
53
|
-
#if (len(arr)!= 2):
|
|
54
|
-
# can_info.append(None)
|
|
55
|
-
#else:
|
|
56
|
-
#You can customize here for you own column name format.
|
|
57
|
-
#这里需要做容错的处理,如果信号中有下划线,但不是数值就会出错。
|
|
58
|
-
# channel_id =int(arr[0])
|
|
59
|
-
# message_id = int (arr[1],base=16)
|
|
60
|
-
|
|
61
|
-
|
|
62
|
-
|
|
63
|
-
current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
|
|
64
|
-
print(" " + current_time)
|
|
65
|
-
blfwriter = BLFWriter(self._outputFilename)
|
|
66
|
-
|
|
67
|
-
|
|
68
|
-
#itorator for each row and data column.
|
|
69
|
-
#遍历解出来的每一行数据
|
|
70
|
-
for row in vdf.objects():
|
|
71
|
-
if blfwriter.start_timestamp == None :
|
|
72
|
-
blfwriter.start_timestamp = row[0]//1000
|
|
73
|
-
#第一列是时间,所以从第二列信号数据开始分析
|
|
74
|
-
#time for first column, so we start from the second column.
|
|
75
|
-
for i in range (1, len(row)):
|
|
76
|
-
#store the signal byte array for not null column data.
|
|
77
|
-
#如果信号非空,则生成相应的数据
|
|
78
|
-
if row[i] != None and isinstance (row[i], list) and can_info[i-1][0]!=-1:
|
|
79
|
-
msg = Message(timestamp=row[0]/1000.0, channel=can_info[i-1][0] -1 ,arbitration_id=can_info[i-1][1],data= row[i], is_fd=True, is_extended_id = False)
|
|
80
|
-
frame_type = 0
|
|
81
|
-
if (can_info[i-1][2] ==2 ):
|
|
82
|
-
frame_type = 11 #LIN_MESSAGE_TYPE in blf
|
|
83
|
-
#写入BLF文件
|
|
84
|
-
blfwriter.on_message_received(msg, frame_type)
|
|
85
|
-
|
|
86
|
-
elif row[i] != None and isinstance(row[i], (bytes, bytearray)) and can_info[i - 1][0] != -1:
|
|
87
|
-
# if length > 64, skip
|
|
88
|
-
if len(row[i]) > 64:
|
|
89
|
-
continue
|
|
90
|
-
msg = Message(timestamp=row[0] / 1000.0, channel=can_info[i - 1][0] - 1,
|
|
91
|
-
arbitration_id=can_info[i - 1][1], data=row[i], is_fd=True, is_extended_id=False)
|
|
92
|
-
frame_type = 0
|
|
93
|
-
if (can_info[i - 1][2] == 2):
|
|
94
|
-
frame_type = 11 # LIN_MESSAGE_TYPE in blf
|
|
95
|
-
# 写入BLF文件
|
|
96
|
-
blfwriter.on_message_received(msg, frame_type)
|
|
97
|
-
|
|
98
|
-
|
|
99
|
-
elif row[i] != None and can_info[i-1][0]!=-1:
|
|
100
|
-
data=[1]
|
|
101
|
-
data[0] =row[i]
|
|
102
|
-
msg = Message(timestamp=row[0]/1000.0, channel=can_info[i-1][0] -1 ,arbitration_id=can_info[i-1][1],data= data, is_fd=True, is_extended_id = False)
|
|
103
|
-
#写入BLF文件
|
|
104
|
-
blfwriter.on_message_received(msg)
|
|
105
|
-
|
|
106
|
-
#finalize the BLF file and flush to disk
|
|
107
|
-
#将BLF文件终结,写入磁盘
|
|
108
|
-
blfwriter.stop()
|
|
109
|
-
|
|
110
|
-
class VswToAscConverter:
|
|
111
|
-
'''
|
|
112
|
-
A seekable reader class for wrapping around byte array when data file has already been
|
|
113
|
-
read into byte array.
|
|
114
|
-
'''
|
|
115
|
-
def __init__(self, inputPaths, outputFilename, signals=[]):
|
|
116
|
-
self._seekables = []
|
|
117
|
-
for fname in inputPaths:
|
|
118
|
-
inFile = open(fname, "rb")
|
|
119
|
-
data = inFile.read()
|
|
120
|
-
self._seekables.append(VDataByteReader( data))
|
|
121
|
-
self._outputFilename = outputFilename
|
|
122
|
-
self._signals = signals
|
|
123
|
-
self._deletedKeyFormat = None
|
|
124
|
-
|
|
125
|
-
def setDeletedKeyFormat(self, deletedKeyFormat):
|
|
126
|
-
'''
|
|
127
|
-
:param deletedKeyFormat: deletedkey format for 64k page
|
|
128
|
-
:return:
|
|
129
|
-
'''
|
|
130
|
-
self._deletedKeyFormat = deletedKeyFormat
|
|
131
|
-
|
|
132
|
-
def convert(self, colParserFun=colParser):
|
|
133
|
-
factory = VDataReaderFactory()
|
|
134
|
-
factory.setDataReaders(self._seekables)
|
|
135
|
-
factory.setSignals(signals=self._signals)
|
|
136
|
-
if self._deletedKeyFormat is not None:
|
|
137
|
-
factory.setDeletedKeyFormat(self._deletedKeyFormat)
|
|
138
|
-
reader = factory.open()
|
|
139
|
-
vdf = reader.df()
|
|
140
|
-
#print(vdf.cols)
|
|
141
|
-
#store the coloumn index to channel_id, message_id tuple mapping.
|
|
142
|
-
#这里用来保留信号列与channel_id, message_id之间的对应关系,第一列总是为时间,所以会少一列
|
|
143
|
-
can_info= []
|
|
144
|
-
cols = vdf.cols()
|
|
145
|
-
for signal in vdf.cols():
|
|
146
|
-
channel_id, message_id, frame_type = colParserFun(signal)
|
|
147
|
-
if frame_type!=2:
|
|
148
|
-
can_info.append([channel_id,message_id&0x7fffffff, message_id&0x8000000 != 0])
|
|
149
|
-
else:
|
|
150
|
-
can_info.append([-1,-1, -1])
|
|
151
|
-
|
|
152
|
-
|
|
153
|
-
current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
|
|
154
|
-
print(" " + current_time)
|
|
155
|
-
writer = ASCWriter(self._outputFilename)
|
|
156
|
-
|
|
157
|
-
#itorator for each row and data column.
|
|
158
|
-
#遍历解出来的每一行数据
|
|
159
|
-
for row in vdf.objects():
|
|
160
|
-
#第一列是时间,所以从第二列信号数据开始分析
|
|
161
|
-
#time for first column, so we start from the second column.
|
|
162
|
-
for i in range (1, len(row)):
|
|
163
|
-
#store the signal byte array for not null column data.
|
|
164
|
-
#如果信号非空,则生成相应的数据
|
|
165
|
-
if row[i] is not None and isinstance(row[i], (list)) and can_info[i - 1][0]!=-1:
|
|
166
|
-
msg = Message(timestamp=row[0]/1000.0, channel=can_info[i-1][0]-1,arbitration_id=can_info[i-1][1],data= row[i], is_fd=True, is_extended_id =can_info[i-1][2])
|
|
167
|
-
#写入ASC文件
|
|
168
|
-
writer.on_message_received(msg)
|
|
169
|
-
elif row[i] is not None and isinstance(row[i], (bytes, bytearray)) and can_info[i - 1][0]!=-1:
|
|
170
|
-
# if length > 64, skip
|
|
171
|
-
if len(row[i]) > 64:
|
|
172
|
-
continue
|
|
173
|
-
msg = Message(timestamp=row[0]/1000.0, channel=can_info[i-1][0]-1,arbitration_id=can_info[i-1][1],data= row[i], is_fd=True, is_extended_id =can_info[i-1][2])
|
|
174
|
-
#写入ASC文件
|
|
175
|
-
writer.on_message_received(msg)
|
|
176
|
-
elif row[i] is not None and can_info[i - 1][0]!=-1:
|
|
177
|
-
data=[1]
|
|
178
|
-
data[0] =row[i]
|
|
179
|
-
msg = Message(timestamp=row[0]/1000.0, channel=can_info[i-1][0] -1 ,arbitration_id=can_info[i-1][1],data= data, is_fd=True, is_extended_id = can_info[i-1][2])
|
|
180
|
-
#写入ASC文件
|
|
181
|
-
writer.on_message_received(msg)
|
|
182
|
-
|
|
183
|
-
#finalize the ASC file and flush to disk
|
|
184
|
-
#将ASC文件终结,写入磁盘
|
|
185
|
-
writer.stop()
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|
|
File without changes
|