AI CAN Bus Reverse Engineering [Claude Code] — Transcript

Full transcript

1. 0:24So in this video, I will show you something that I think is pretty insane, which is how you can use AI
2. 0:30to help you reverse engineer proprietary CAN bus signals from a car, truck, ship,
3. 0:36whatever piece of equipment you have. To do so, I will be using our CANsub.2 CAN bus
4. 0:42interface, as well as python-can and a custom Claude Code skill that I built for this purpose.
5. 0:47And as you will see from the three practical showcases I go through this workflow is
6. 0:53extremely powerful and I would actually say this is now our recommended method for all of our end users
7. 0:58that are looking to do CAN bus reverse engineering. As always don't take my word for it in
8. 1:04the description you will find links for the test data used behind this. The skill is 100% open
9. 1:10source so you can go and try it out after this video and I will show you exactly how to do it.
10. 1:17Why do you need to reverse engineer a CAN bus data in the first place? If you're not super familiar with
11. 1:22CAN bus, the way it works is essentially that you can record the raw CAN bus frames from a
12. 1:28vehicle, a truck, a car, a ship and the like using for example a CAN bus interface
13. 1:34or a CAN bus data logger. But what you get is essentially just a lot of data bytes and CAN IDs
14. 1:39and you will not be able to make any sense of the data unless you are the manufacturer only
15. 1:45the manufacturer is able to say how to go from the raw CAN bus data into what we call physical
16. 1:51values meaning the decoded and scaled signals such as speed in kilometers
17. 1:56per hour RPM temperatures in degrees Celsius and the like now
18. 2:02there can be some exceptions to this rule as an example in the heavy duty world
19. 2:07J1939 is a standardized protocol that is used by most manufacturers.
20. 2:13And as a result, you will be able to decode a large share of the data that you find on an average truck
21. 2:18if you buy a J1939 DBC file. And in a similar way, if you have your own
22. 2:24car, and if we're talking a non-electric car, you can typically get some data through
23. 2:30OBD2 requests, essentially asking the car to provide you with speed, RPM, and some
24. 2:36other parameters. But what you're getting is essentially the discount version of what is available on
25. 2:41the CAN bus. You are only getting a light subset, in this case, through OBD2.
26. 2:45So if you want specific signals, or if you want the more rich data that is being communicated in your
27. 2:51car, you essentially need to reverse engineer that information. And that's the exercise that
28. 2:57we'll go through today. And this is relevant not only if you are a car enthusiast, but also in
29. 3:03you could say the professional world if you are an aftermarket provider of let's say telematic services
30. 3:09in a mixed heavy-duty vehicle fleet then you often need to do at least some reverse
31. 3:15engineering in order to complete a DBC file and get the information you need in order to solve the
32. 3:21use case you need. The problem with doing reverse engineering in
33. 3:27practice the classical way is that you essentially need to be a bit like Tank from the Matrix
34. 3:32you need to use tools like SavvyCAN and you need to do a lot of you can say ad
35. 3:38hoc human analysis on the fly where you're looking at bits of the CAN data bytes that are flipping
36. 3:44you try to correlate this versus what you're seeing in the real world and if you get really really good
37. 3:50at it then you are able to in many cases reverse engineer at least some CAN signals
38. 3:55but it can take hours to do so and in my opinion it is only really possible
39. 4:01if you have some serious expertise within the field. So what I wanted
40. 4:07to do was essentially to check are we able to leverage AI in order to make the CAN bus
41. 4:12reverse engineering exercise more easy and more accessible to non-technical users
42. 4:18and basically the way I went around this was to build a Claude Code skill and I'll explain
43. 4:24a bit more in a moment and I tested this on a diverse set of CAN signals and real
44. 4:29world practical exercises in order to iterate towards something that actually works really really well
45. 4:34now I'm not trying to push my particular skill it's 100% open source you can go
46. 4:40and pull it and you can use it also quite easily with other tools than the CANsub. My goal is
47. 4:46more to showcase a workflow that I think works really well and if you want to use the
48. 4:52skill that's fine but you can also build it from scratch yourself and let me explain essentially
49. 4:58how I went around building this particular skill so first of all if you're not familiar
50. 5:03with Claude Code I strongly recommend just watching some quick videos on this on YouTube but
51. 5:09the gist of it is that it's a bit like ChatGPT that you may have tried in your browser but where it
52. 5:15has access to all of the files folders Python scripts and the like and can run scripts
53. 5:21on your PC so it's a bit like running a chatbot locally, where it has access to tools.
54. 5:27And if you're using something like Claude Code frequently for the same type of workflow, then it can be
55. 5:33a good idea to create what is called a skill for Claude. So a skill is essentially just
56. 5:38a folder consisting of some files and potentially some scripts. And in our
57. 5:44particular case, the skill I built contains some instructions for Claude that tells it when are you
58. 5:50supposed to use this skill, what are the workflows that are supported within this skill and step by
59. 5:56step how do you go through it specifically in this case reverse engineering some arbitrary CAN bus
60. 6:02signal that the user is interested in and in order to enable Claude to understand stuff
61. 6:08about reverse engineering I have provided it with some reference articles but I have also provided it
62. 6:14with details on our CANsub.2 so the product I use for this as well as
63. 6:20documentation on the python-can integration for the CANsub.2 so that Claude will know what are the things
64. 6:26it can do, for example if it needs to do some quick scripting that goes beyond what is available in the
65. 6:31skill. But for the core workflows that are being used in this skill, Claude has also built
66. 6:37a number of Python scripts that use the python-can integration in order to access the CAN bus, for
67. 6:43example through the CANsub.2, but also to analyze CAN bus data in the form of CSV files as
68. 6:49well as build DBC files as the final output from the exercise and this is
69. 6:54critical because Claude will not have a chance at reverse engineering anything if it just gets for
70. 7:00example a raw CAN trace that might consist of let's say millions of CAN frames that
71. 7:06is not a good way for a chatbot to operate instead you want to provide it with a
72. 7:11method of getting the insightful results and the statistical results out of various
73. 7:17analyses and only focus on that to keep the context window as minimal as possible for
74. 7:23the chatbot. It can be, you can say, interesting or
75. 7:29intuitive that you could essentially just pass to Claude the full raw CAN trace from
76. 7:35your vehicle, ask it to, you know, reverse engineer everything or even reverse engineer, you know,
77. 7:40specifically speed and then let the AI do some magic. And unfortunately, that's not how the
78. 7:46real world works, at least today. So in order for Claude Code to have a chance at actually
79. 7:52successfully reverse engineering the signal you're interested in, you have to tell it what that signal
80. 7:58looks like. And since you don't have the decoding rules for the CAN bus, you need to provide a
81. 8:04reference signal that closely correlates with the signal that you are targeting.
82. 8:09So if we take speed as an example, the ideal reference signal for a
83. 8:14proprietary speed signal in a car, for example, would be if you have access to getting the
84. 8:20OBD2-based speed. And that is because, as I explained, OBD2 is a standardized protocol
85. 8:25across cars. It is accessible in most modern non-electric cars.
86. 8:31And that means you can use a tool like the CANsub.2 to request speed from the car
87. 8:36let's say every 300 milliseconds and you then have this reference signal in raw
88. 8:42form in the same CSV file as you have your proprietary raw CAN bus data and
89. 8:48These signals will be more or less perfectly correlated which makes it much much easier for Claude to
90. 8:54detect what is the related underlying speed signal. If you don't
91. 9:00have a CAN-based signal, you can also use a vision-based signal. So a good example is, again,
92. 9:06if your car shows the vehicle speed on the car's dashboard in a digital form, then you
93. 9:12can record this with your iPhone or with a webcam, and then the skill has support for using Python
94. 9:17to turn this video into, you can say, a time-series data set, pretty much
95. 9:23giving you the exact same result as you have when you use a CAN-based signal from OBD2,
96. 9:29a GPS-to-CAN module or something similar. So nearly a perfect reference signal.
97. 9:35If these options are not available, as a last resort, the skill also supports that you can use human
98. 9:41input, and this can for example be relevant if you have no digital representation of the signal, but
99. 9:47you are as a human able to monitor it visually. For example, that can be me turning some gauge
100. 9:53on a sensor to CAN module, or it could be something you can observe in your car, but where you are not
101. 9:58able to record it and turn it into digital data. So I will show you how you do that
102. 10:04through a small app in the tool as well. But once you give Claude the reference data, as
103. 10:10well as the raw CAN bus data, it goes through a number of analysis steps, doing
104. 10:15statistical analysis, surveying the CAN bus data, surfacing what are the correlated
105. 10:21target potential candidates for your signal, and based on this and doing a number of different steps
106. 10:27that I'll cover in a moment, it is able to get to a conclusion in almost all of the cases that I have
107. 10:33tested where it has detected the relevant underlying proprietary signal correctly, and it
108. 10:38will then create a DBC file based on this result that you can directly use to decode your data
109. 10:44in tools like webCAN. Now, in this skill here, I've built it around
110. 10:50our CANsub.2 CAN bus interface, and you don't have to use that for
111. 10:56this particular exercise. You can use any CAN bus interface that integrates with python-can,
112. 11:02and you could even go beyond this if you wanted to redo some of the scripts here.
113. 11:07Again, my goal here is to showcase this workflow. If you want to use a different tool, you
114. 11:12can definitely do that. And I would also, to be brutally honest, say that the
115. 11:18CANsub.2 is perhaps a bit over-specced for some reverse engineering use cases.
116. 11:23This is a professional-grade tool that is targeting primarily engineers working at
117. 11:29OEMs in the automotive industry, where it is critical that the tool has a lot of professional-grade
118. 11:35features and functionalities. With that said, I know we have a lot of users within
119. 11:41the CAN bus reverse engineering space, and we have had that on some of our older devices, and I
120. 11:47would say the CANsub.2 is perfect for CAN bus reverse engineering for a number of reasons.
121. 11:53One of the reasons is the fact that the device has this small LCD display on the backside,
122. 11:59and when you are connected to your CAN bus with the CANsub.2, you will be able to monitor things
123. 12:05like the frames per second, the bus load, are you actively in silent mode right now, are
124. 12:11there error frames on the CAN bus, what kind of bitrate are you using, and a lot of stuff like that.
125. 12:17And this is useful because when Claude is doing its thing, you don't really have much transparency into
126. 12:22what's actually happening under the hood through the terminal, in my opinion.
127. 12:26And here I find it to be really, really nice to be able to follow along on the LCD of the CANsub.
128. 12:32The second big thing that the CANsub facilitates is the tool called webCAN.
129. 12:37So this is an optional tool that you can use with the CANsub, along with many other tools.
130. 12:42But it is a browser-based GUI tool that you can essentially access by simply entering
131. 12:48the URL of your device in your browser. And this opens up webCAN directly with no installation
132. 12:54because the tool is actually hosted on the CANsub.2, which is a quite unique combination
133. 13:00that makes it really really practical to use and you can use this offline in your car it doesn't require
134. 13:05internet connectivity and it does pretty much everything that you would find in you can say similar CAN
135. 13:11bus tools and in fact it also does a lot of professional grade stuff that you normally only find
136. 13:17in paid CAN bus software tools this includes things like being able to decode live
137. 13:23with DBC files handle transport protocols like J1939 transport protocols,
138. 13:29and ISO-TP. It also allows you to directly plot and visualize the data that you have recorded
139. 13:35within the tool, which is really, really useful when you want to review in real time if your
140. 13:41DBC file looks to be valid, and I'll show more about that later. The CANsub.2 also
141. 13:46supports silent mode and error frames, which I think are critical features when you are doing CAN bus
142. 13:52reverse engineering, in particular if you're doing it in live and safety-critical vehicles, you want
143. 13:58to be able to use silent mode during that analysis. And finally, the CANsub.2
144. 14:03supports dual CAN buses. Now in many cases this is not necessary, because if
145. 14:09you are able to get the proprietary CAN bus data along with for example OBD2 data
146. 14:15through a single connector in the car, then you're in luck. You have a very simple setup and this
147. 14:21would be my starting point for most users to try out but in many many modern cars
148. 14:26the access to the raw proprietary CAN bus data is going to be deliberately blocked
149. 14:32by the manufacturer through the OBD2 connector and that means you are still able to use the OBD2
150. 14:37connector to get your reference signal and you can do that through for example channel one of the CANsub.2
151. 14:43but then you need to get access to the proprietary raw CAN bus data from another source
152. 14:48and typically the way you do this is that you take a contactless CAN reader you snap it onto the
153. 14:54CAN high and CAN low wiring harness in your car often you need to remove a panel to access this
154. 15:00and now you have the possibility with the CANsub.2 to record both the OBD2
155. 15:06reference signal and the proprietary CAN bus data into the same fully time-sorted
156. 15:12trace view and you can export that CSV from webCAN directly for use by Claude
157. 15:18Code, where if you were to record this separately, the whole point would be lost.
158. 15:23You essentially need to have these two data sources in a single file in order for
159. 15:29Claude to be able to do its thing. If we look a bit more
160. 15:35into some of the actual showcases that I also provide in the article, the first showcase I
161. 15:41do is very simple. I have recorded with the CANsub.2 some data from a car.
162. 15:47This is specifically from a Mercedes E350, where I have some
163. 15:53raw proprietary CAN bus data and I have some OBD2 data as my reference signal.
164. 15:58In this case, I actually asked Claude to reverse engineer two signals up front, speed and RPM, and
165. 16:04I explained that I have available a CSV file which contains also the OBD2 data it needs.
166. 16:09Now in the skill we have packaged our OBD2 DBC file and that allows
167. 16:15Claude to quickly decode the OBD2 signals from this data so it has the
168. 16:21reference signal it needs to identify speed and RPM from the data and if you look at
169. 16:27the steps I take here you will see that Claude is doing a lot of work to trawl through the
170. 16:32data with the different tools and it does a couple of things here it does a survey
171. 16:38of the data so that involves essentially a bit the same steps you might have seen in SavvyCAN and other
172. 16:43tools where you are looking at which bytes and which bits are changing in response to certain
173. 16:49information or certain stuff happening in the real world. Claude is doing the same thing across the
174. 16:55entire log file to get an idea of what are the patterns of the different CAN IDs and the different
175. 17:00payloads in the data here. This serves the purpose of for example identifying
176. 17:06if some of the CAN IDs are irrelevant to the subsequent analysis and also if some of the data
177. 17:12bytes seem to be for example counter signals checksums or other types of signals that might
178. 17:18disturb the subsequent correlation analysis but which are not really relevant for the specific
179. 17:24analysis or reverse engineering exercise once we've done that step Claude will do a
180. 17:29correlation analysis and in here it will essentially rank different candidate fields
181. 17:35so that will be you know byte chunks of the data and it will try and look at how well these
182. 17:41correlate against the reference signal without having to take into account the scale and the offset
183. 17:46because we do not know that information yet and from this analysis Claude will typically get a few
184. 17:51candidate potential signals and it can then do the next step which is a bitsearch
185. 17:58And here Claude does essentially all of the potential variations of, you know, bit start, bit length,
186. 18:04endianness, signed, unsigned, all of that stuff in a lot of iterations.
187. 18:10And again, the idea here is to correlate and identify which of these combinations will
188. 18:16give the best match against the reference signal that it is provided. Once it has done this exercise,
189. 18:21Claude should have essentially the relevant bits, you can say, of the signal that we're trying to
190. 18:27reverse engineer. And now it's just a matter of doing more of a statistical exercise to identify
191. 18:33what is the scale factor that will make this graph that we can plot from these extracted
192. 18:38bits look like the graph of the decoded signal we're matching up against.
193. 18:43And once the scale has been identified, the second step is to find the offset so that you have all of
194. 18:49the information that is required for a CAN signal in order to create a DBC file of this.
195. 18:55And once Claude is done with that, it will create a DBC file for this particular signal.
196. 19:01And as you will see from the video here, Claude does this in a nice way where it creates a decoding
197. 19:07output folder, it creates a subfolder for the application based on the context I provide, and it
198. 19:13also does a subfolder below that for the specific signals that we are reverse engineering.
199. 19:18And this is where Claude will put the DBC file. It will also put the plot showing how well this
200. 19:24correlates against the reference signal and it will also put some of these analysis plots mainly for
201. 19:30us to understand what is actually going on under the hood but in some cases this can also be useful to
202. 19:35guide Claude in the right direction if it goes off track in the analysis so
203. 19:41as was expected in this case Claude was able to reverse engineer speed and RPM
204. 19:47without any issues because it had more or less a perfect reference signal but this may
205. 19:53seem trivial but this is a really really powerful way of achieving this and not something that a non-technical
206. 19:58person would otherwise be able to do even if they have the reference signal available now
207. 20:04to take it one step further I also did a test in a car basically an old
208. 20:10Opel Astra where I get access to the car I set up the CANsub to request some OBD2
209. 20:16speed information to be sure that I have a reference signal for my subsequent analysis
210. 20:21but the goal here is to essentially showcase what would I do if no OBD2 data
211. 20:27was available. For example in an electric car you often don't have the luxury of OBD2 data
212. 20:32and therefore you need to look at what is the second best thing that you have and in my opinion that
213. 20:38is the OCR method where you record a digital value of the signal from your
214. 20:44car's dashboard for example with an iPhone or better I would say with a webcam that is synchronized
215. 20:50to your PC time and thereby the CANsub's time and you can essentially
216. 20:55record this data while you are driving around and in my experience you want to
217. 21:01do this if possible later in the day so there's not too much sunlight and you would also
218. 21:07want to do it in a way where the webcam is quite stably positioned in order to minimize the drift around
219. 21:13but I did the worst case scenario and it turns out that Claude and the script utilities are
220. 21:19able to handle this pretty much perfectly well and as evident from the video here
221. 21:24one of the steps in this workflow is that you get your video and you get a
222. 21:29signal or you get essentially Claude's and the script's output time series
223. 21:35and you get sort of the current value at the frame you are at in the video so you can quickly review if
224. 21:41your video turned into the expected time series data and how many errors you had
225. 21:46in case you want to go back and redo it. But typically you can get quite far with
226. 21:52quite simple means with this. Again now Claude has a reference signal available and it is able
227. 21:58to run through the exact same analysis as in the OBD2 case and reverse engineer the proprietary speed
228. 22:04and in this case I also recorded the OBD2 speed just as a proof to show that it was in
229. 22:10fact the correct speed we got but Claude of course did not have access to the OBD2 speed in this
230. 22:16particular exercise here now let's try something that is a bit harder which is
231. 22:22to say what do we do if we don't have such a perfect reference signal. And to showcase this I'm
232. 22:27essentially testing with the CANsub.2 and a module we have a sensor to CAN module called
233. 22:33CANmod.input. The CANmod.input is able to produce CAN frames based on
234. 22:38measurements of voltage in the 0 to 10 volt range. So for this particular exercise I
235. 22:44take my CANmod.input and we have a small potentiometer PCB board which has eight
236. 22:50gauges that you can turn with like a small tool in order to translate that into a millivolt
237. 22:55output which by the CANmod.input gets translated into a CAN frame and some
238. 23:01CAN signals. Now I know what the true DBC file is for the CANmod.input but of course I don't
239. 23:07tell Claude that and I think it's fairly to be expected that Claude did not find this as part of its
240. 23:13training data. It is a bit niche. So what I do in this exercise is to say,
241. 23:19can I essentially move around this gauge in real time with my right hand,
242. 23:24while at the same time with my left hand, I use the skill's built-in web app to
243. 23:30move a slider up and down. So the way this works is that I have told Claude a bit of context up
244. 23:36front, as you can see as in my prompt here. And this allows Claude to start up this web
245. 23:42app with the settings already matching the context I provided so I don't have to fill in any
246. 23:48fields. Claude has taken care of that and then it will ask me to do some captures in real
247. 23:53time with the CANsub.2 where it records data while I am doing something with the reference
248. 23:59signal in real time. So I would essentially start the capture and then the first pass
249. 24:05is to do this time slider, or not a time slider, but this slider from zero to 100%,
250. 24:10representing essentially me moving this gauge from zero to 100%. And this is hard,
251. 24:16as you will see from the comparison graph. It is hard to match these exactly.
252. 24:21So I do it as best as possible, and I do it a few times from zero to 100 and back to zero,
253. 24:26and try as much as possible to follow along with both of my hands. But
254. 24:32in order to get a more precise second pass of this the skill also supports that you can set
255. 24:38in some sample observations at different values you can say of the reference signal
256. 24:44so in my example this corresponds to setting the gauge to zero percent and then hitting the zero
257. 24:50percent sampling then I will see from the chart in the app that it samples for these
258. 24:55two seconds then I can move the gauge to the next point, maybe that's 50%,
259. 25:01and again I can sample for two seconds, etc. And I can do this a number of times, and that
260. 25:07gives a bit of an anchor for the different signal values that is less dependent on my
261. 25:12poor and noisy human input that I'm able to provide in the first pass.
262. 25:18So when I have provided this, I essentially tell Claude that now we're done, please proceed,
263. 25:24and then Claude goes through the next steps as before. And again, in this case,
264. 25:30I think this is probably one of the ones where I'm more surprised that it is able to manage this.
265. 25:35But Claude is able to take even this very, very noisy reference signal and manage to
266. 25:41decode the correct decoding rules for the CANmod.input based on this.
267. 25:48And something it also does that is quite nice in the context is that it often discovers that maybe there
268. 25:54are separate signals that are encoded in the same way. So in this example with the CANmod.input, I'm
269. 25:59asking it to reverse engineer the first gauge, but I did tell it that there are eight.
270. 26:05So based on the decoding rules it found for the first gauge, it sort of figures out that probably
271. 26:11the next gauge values are also encoded in these and these data bytes.
272. 26:17And it will then ask you, do you want to proceed to try and reverse engineer these?
273. 26:21And I essentially tell Claude hey based on your hypothesis try and create the full DBC file
274. 26:26basically do the exercise for all of the remaining gauges but don't await my input for it just
275. 26:32build the combined DBC and it will do so and then I will take this DBC
276. 26:38file load it into the webCAN tool and then I can sit and move the gauges for all of the eight
277. 26:44gauges and verify that the decoding rules match I'm essentially seeing on my screen when I plot
278. 26:50this data exactly what I'm doing physically in the real world so I would say this is a useful
279. 26:56exercise if you are busy and want to just get you know a couple of extra signals down and then you
280. 27:01prefer to verify the data rather than go through the manual exercise each time now
281. 27:09if you want to try this yourself you can get the CANsub.2 as mentioned I would get the OBD2-DB9
282. 27:15adapter to start with and then you can try, if you can, you know, get the data from your car, the
283. 27:20proprietary CAN data through the OBD2 connector itself. If so, that's the simplest solution.
284. 27:26If not, then you can get the contactless CAN reader we have and maybe like a cigarette receptacle
285. 27:31adapter we provide for powering this. And then you can try the contactless method.
286. 27:36I just would stress this does require a bit of digging through your car, removing
287. 27:42a panel here and there in order to find out where the CAN high and CAN low is.
288. 27:46So this is a bit more for the experts or the technical users that want to do this.
289. 27:52But if you are patient, you can also do it even without prior experience.
290. 27:57If you want to just try out the skill right away without our devices, you can also get the test data
291. 28:02that I use for some of these showcases. So you can download that and you can use actually the full
292. 28:08workflow from showcase one and showcase two just with that data. My video that I recorded for
293. 28:14the second showcase is also included in there. The skill itself is available on GitHub and
294. 28:20you can find the link in the description and you just go to the GitHub page and you can essentially
295. 28:24clone or download the zip file with the skill, put it into some folder
296. 28:30and then you want to open up Claude Code from that folder. And in the readme on the GitHub page,
297. 28:36I describe some of the details like how do you set up Claude Code? How do you get the exact same setup as
298. 28:42I have in Visual Studio Code with the plugin which I like so you can go there and find the
299. 28:48various steps inside my estimate is that setting this up will take around 10
300. 28:54minutes so definitely try it out with the sample data but to summarize I
301. 29:00did many many more tests than what I showcase here and I would say across all of the tests I'm pretty
302. 29:05much blown away by how effective this workflow is in pretty much all of the signals
303. 29:11that were available in the proprietary CAN data and where I did have a reference signal that was
304. 29:17clean it was pretty much a hundred percent success there are some cases where Claude goes off on
305. 29:23a tangent and you need to help it a bit but I would say even in these cases it's often able based on you
306. 29:28know logical analysis to say hey this correlation is not as good as expected
307. 29:33that's probably not the right path let me review again and it goes back and forth and actually even in
308. 29:39these cases ends up with the right signal which is equally impressive as these
309. 29:45single shot showcases that I showed you before I think the really really big impact here is
310. 29:51that when I tell our users that yes you can reverse engineer CAN bus data
311. 29:56using the classic methodology, I typically also say that you should expect to spend two to
312. 30:02six hours per CAN signal that you are reverse engineering. And I honestly think that is the realistic
313. 30:08time it takes for somebody that does not have multiple years of experience within this field.
314. 30:13With the skill here and with the methodology, I would say that the exercise actually takes
315. 30:19closer to five to ten minutes per CAN signal, with most of this being me drinking coffee
316. 30:25in the background while Claude is running through all of the steps of course you need to
317. 30:30record the data but again using something like the CANsub.2 you can very quickly get the
318. 30:36raw CAN data and the reference signals that is also not a huge exercise
319. 30:40but again just like the classic methodology this is not some magic AI
320. 30:46overlord doing hocus-pocus so you cannot simply provide it the raw CAN data without a
321. 30:52reference signal that is going to be useless for Claude you are limited still to what signals
322. 30:58you are able to get a clean reference for but I definitely hope you found this useful
323. 31:03and interesting and if you did make sure to like and subscribe the video but more importantly I really
324. 31:08hope you'll share this in your community and you're always welcome to reach out to us if you want to
325. 31:14discuss this if you have suggestions or if you just have questions about using our products thanks for
326. 31:19watching and see you next time on my next video