WinOLS Mastery: Map Identification & Editing: Finding and Defining Maps - 3D Maps
Watch This Course
$299 USD $149.50 USD
-OR-
Or
8 easy payments of only $18.69
Instant access. Easy checkout. No fees.
Finding and Defining Maps - 3D Maps
21.47
| 00:00 | - For our next map, we're going to raise the complexity a little bit on two separate fronts. |
| 00:05 | First of all we're going to now find a 3D map, so simply a map with an X as well as a Y axis. |
| 00:13 | With this particular map that we're going to be looking for, the other added complexity is that the map data, the Z axis data uses an eight bit format. |
| 00:22 | One of the axes uses 16 bit and the other uses eight bit so this just adds a little bit of complexity when we're actually looking for this map or more to the point depending on how we've got OLS set up, the axes will look a little bit unusual and may not make sense straight away. |
| 00:40 | Let's have a look first of all at what we're actually looking for. |
| 00:44 | We can see here we've got our screenshot. |
| 00:47 | These are the three maps that we're going to be looking for, we've got one, two, and three, these are our driver requested lambda maps. |
| 00:57 | Now what I just circled there is our map data and what we can see is we've got our axes right here at the front and there are axes available there in that screenshot for each of those maps. |
| 01:10 | What you can see here is in our demonstration or screenshot, this is currently being viewed at eight bit and specifically what I want you to take note of is what the second axis looks like there. |
| 01:25 | It's essentially just complete garbage. |
| 01:27 | Let's load up a second screenshot where this data is now being viewed in 16 bit format instead of eight bit. |
| 01:35 | Alright so now we can see with our second screenshot, 16 bit this time as I mentioned and now our axes look a little bit more sensible, they make a little bit more sense to us. |
| 01:46 | Notice that the data itself, the map data doesn't really look appreciably different there, depending whether we're looking at it as a 16 bit or eight bit and that's why I recommended at the start that you should generally have OLS set up in 16 bit format and this way you're going to get a better view or a view that makes more sense of all of the maps. |
| 02:10 | Alright so now that we know what we're looking for, let's jump back into OLS and we'll see how we can go about finding that. |
| 02:18 | Alright so at this stage we're leaving off essentially where we were with our maximum relative engine load maps. |
| 02:27 | What we're going to do is just click off to the right hand side here and we'll cycle through a screen at a time and look for that pattern. |
| 02:35 | I'll note here that at the moment I've got the X set up with a 400% magnification. |
| 02:42 | The actual screenshot we had there was magnified a little bit more but for the moment, this will be absolutely ample, in fact we could drop this back a little bit to 200%. |
| 02:51 | We know those patterns we're looking for, those three separate maps so let's just cycle through until we find those. |
| 03:00 | Alright we've just gone too far, just saw them pop up here. |
| 03:03 | And here we go, we've got our three maps. |
| 03:07 | So let's just use our little arrow here, we'll get these a little bit more central and now we can zoom in and get a better appreciation for what they look like. |
| 03:15 | So at the moment we know that we've got OLS set up in 16 bit mode and again the axes look somewhat sensible. |
| 03:25 | Let's just click to eight bit and we'll see that again we can just zoom in a little bit further here, we'll see that the second axis just becomes complete garbage so that just indicates we've got one axis there that's eight bit and we've got one that's 16 bit. |
| 03:40 | The values here which we'll dive into in a little bit more detail, are eight bit and these are our driver requested lambda values. |
| 03:49 | So if we just have a quick look here at the actual values at a particular point we can see down in the bottom here we've got our cursor position and the value there is 128. |
| 04:00 | That particular number is one to take note of because that is indicative, once we know what we're looking for, that we are most likely looking at a lambda target table. |
| 04:11 | The simple reason as we will see once we get into our scaling is that when we divide 128 by itself, it of course gives us a value of one. |
| 04:18 | We add some precision in terms of a couple of decimal places and all of a sudden we've got our lambda target. |
| 04:26 | So again, when you're first getting started, obviously you're not going to know that 128 is a number that should make sense to you but you will build up this knowledge as you go. |
| 04:34 | So let's have a more detailed look at this and see how we can actually find and define these particular maps. |
| 04:42 | For a start, let's just click over on the first of these axes here, which we can see the general trend or shape that we'd expect with an axis, we are currently in eight bit viewing mode which we can see that this axis actually does make sense like this, it's a typical shape. |
| 05:01 | So again we'll go down to our bottom left hand corner and as I move the cursor to the left using the left arrow, we want to see the numbers that we end up with. |
| 05:11 | OK so the lowest number we've got there, well that first number that we've got there I should say, 15, and then that's followed by six, then we actually start jumping up quite significantly, we've got 20 then 25 then 31. |
| 05:24 | So what that means there, 15 the first number, this is the axis size so this is a table that is 15 x 6. |
| 05:33 | The first value there 15, this is the Y axis so 15 up or 15 down I should say and then six wide so that's the width of the table. |
| 05:44 | Alright let's just see where abouts this table is and how we can actually go about defining it. |
| 05:50 | So let's just click somewhere near the end of the data area, so we know that this is going to be the data area and let's now go down and we'll convert this to text view. |
| 06:01 | Now at the moment we aren't going to be able to make too much sense of this because you can see in the bottom right hand corner, we've currently got our width set to a value of 12. |
| 06:12 | We've just found that this is a 15 x 6 table, so 15 vertical, 15 in the Y direction and six in the X direction so what we want to do is use our W key and shrink that down until we've got a value of six. |
| 06:27 | Now I clicked somewhere near the end of the data so we can see where the cursor is here. |
| 06:34 | Got a value of 116, not too worried about that at the moment, it'll all make sense fairly shortly and we can see that a large portion of this table is made up with values of 128 and again, as I mentioned, 128, we divide it by itself, lambda 1.0 so this is again a good indication that we are looking at our lambda target table. |
| 06:53 | But at the moment our alignment isn't quite right, we can see graphically out to the right hand side, this just doesn't make sense, the shape of this, so what we're going to do is just find our first value of 128 which we can see is here and what we're going to do is use the control key and we're going to just scroll across until that table all jumps into place and we can see that's what it's done now, we've actually got that first value of 128 that I clicked on, that is now the left most value and we can see that the little graphical display out here on the right hand side now actually has a fairly consistent shape to it. |
| 07:34 | So this is what we're looking for when we're using our text mode to find and define these maps. |
| 07:40 | So we know that we are six wide, we've already got our first one highlighted which is number one, so holding down the shift key and right arrow, one, two, three, four, five, six, that is the width of our table. |
| 07:52 | Now we're going to go down 15 so we've got our first one highlighted so one, two, three, four, five, six, seven, eight, nine, 10, 11, 12, 13, 14, 15. |
| 08:02 | Now you can see that the block of numbers that I have just highlighted corresponds quite nicely with the shape of our little graphical display out here. |
| 08:12 | If we'd gone down any further we can see that we get this big step or jump. |
| 08:17 | Likewise if we went up above this, again there isn't a consistent trend so I'm confident there that I've got the right area of our table highlighted. |
| 08:26 | So what I can do now is press the K key to mark this and turn it into a map. |
| 08:31 | At this stage we've got no axes applied to this so we can see we've just got 0-14 on our Y axis and we've got 0-5 on our X axis, that's OK we can now go ahead and sort that out, so let's press escape. |
| 08:47 | We'll press delete, before I do that, you'll notice that OLS has actually seen a trend here and it's already marked what it thinks is the next table below that but for the moment we'll press delete, we want to get rid of that and we can have a little look a little bit deeper into this. |
| 09:04 | Now if we just for a moment go back to our 2D view, we already know that the axes values for the table are right ahead of the table. |
| 09:14 | So this is where we obviously want to be looking. |
| 09:16 | Let's head back to text and see what we can actually make out of this. |
| 09:19 | So this is the area essentially immediately before that table that corresponds to our 2D graphical view. |
| 09:27 | If we look through these numbers, what we're looking for is those first numbers that we found that corresponded to our table size. |
| 09:35 | We can see right here we've got those values, 15 x 6, remembering that these are defining our Y and our X values, or X axis values. |
| 09:46 | And following those will be our axis values so 15 here then by six, the first value after those two is going to be the first value of our Y axis. |
| 09:58 | So what I can do is highlight that, we can right click on that and we come down here, we've got the option to click here, address as Y axis of the next map. |
| 10:08 | So I'm going to click go ahead on that and that's what that's going to do. |
| 10:13 | Now the very next thing we can do is repeat this process with our X axis. |
| 10:18 | In this case our X axis is going to be our throttle position and this is the axis that is in 16 bit, the one that didn't make sense when we were looking at it graphically in our 2D view so if we just switch across to 16 bit for a moment. |
| 10:33 | And now in 16 bit we've got six values here, so I'll click on the first of those, we'll right click on that and we'll come down and now we've got the option to set this as the address as the X axis of the next map. |
| 10:47 | We'll click on that and now if we double click, we've now got some axis values. |
| 10:51 | Now of course on face value again these don't look to make too much sense. |
| 10:57 | We've got values up to 32768 on our horizontal axis and we've got 20 through to 163 on our Y axis. |
| 11:08 | Let's see how we can now turn these into some values that we might actually understand. |
| 11:13 | Now if you've been taking notes or noticing the trends in our logical number sequence, you'd have hopefully already recognised that 32768 is one of these numbers. |
| 11:26 | Remembering I've said that this is a throttle position axis so would make sense if we divide this by itself, we're going to end up with a value of 100 so let's just double click on for a start and we're going to enter a description for the X axis. |
| 11:43 | In this case the X axis is our driver pedal position so let's enter that. |
| 11:54 | Alright we've got our description for that particular axis entered and we want to now enter our factor and offset so we're going to use our little function icon here, click on that and we're going to click on the output radio button. |
| 12:08 | Let's just move this by dragging the box so we can actually see what happens to the values in our X axis as I go through this, So I'll leave that highlighted here. |
| 12:19 | So let's enter a value of 32 and that brings us to 1024 seven. |
| 12:26 | And then let's enter a decimal point, 68. |
| 12:30 | So this is how we can manipulate that. |
| 12:32 | Obviously if we entered a value, and let's just try this, 32768, we've got a value of one. |
| 12:38 | So that's obviously not what we want there so sometimes there is the requirement here to manipulate the location of the decimal point in our factor in order to get a sensible axis range. |
| 12:50 | so 32768 wouldn't do it but 327.68 does. |
| 12:56 | Let's click OK here and one of the reasons that this is a high resolution 16 bit value is that it does allow for a lot of precision so we can go ahead here and add a couple of decimal places as required. |
| 13:10 | Obviously at this stage you're doing nothing but we could also manipulate the values in that axis if required. |
| 13:16 | OK we can click OK there, that'll close down that axis, our job's done there. |
| 13:21 | Now let's double click on our Y axis here and in this case the driver's requested lambda table is going to be throttle position or driver's pedal position vs engine speed so this is going to be our engine speed axis. |
| 13:34 | Now obviously at the moment, maximum value of 163, that's not going to quite cut it. |
| 13:39 | Also again we already know this is an eight bit axis value so not a lot of resolution in here but frankly it's just not required. |
| 13:47 | So let's go through this process, our description here of course is engine speed. |
| 13:53 | And we can fill out this in revs per minute, we can give it an ID of RPM if we wish. |
| 14:01 | And we also want to come down here to our scaling factor. |
| 14:06 | In this case again, if we look at our cheat sheet here we know that in Bosch's controllers, a factor here of multiplying by 40 is quite frequently used for RPM so let's just try that. |
| 14:20 | I'll multiply by 40 and now we've got 800 through to 6520 so that spans the sensible range that we'd expect our engine to run so everything's looking pretty good here. |
| 14:31 | We now need to define our map values, our Z axis values. |
| 14:36 | So we can just come across here in the tabs at the top to our map but again I'd recommend that for the moment just for simplicity, so you don't make any mistakes, you actually close that down and then double click on the Z axis values. |
| 14:53 | So this particular map, the overall map here is called driver's requested lambda. |
| 15:00 | So we'll enter that, we can copy and paste that, control A will highlight everything, control C will copy it, we then can come down to our description, control V will paste that in. |
| 15:14 | Now we can go ahead and actually scale the values so we've already talked about the fact here that 128, if we divide it by itself, we're going to get a value of one, so let's go ahead and do that. |
| 15:27 | We're going to come down and click again as usual on our little function icon. |
| 15:31 | We'll click on the output radio button and let's again just drag this out of the way so we can see what's happening while I'm entering these values. |
| 15:40 | So 128, value of one, obviously not particularly challenging to figure that out there. |
| 15:46 | So we're OK with that, let's click OK but this isn't a really good way of describing lambda, we don't really have any precision at all so let's come down and add a couple of decimal places here and now all of a sudden with a bit of precision added, we've got what does look to be a pretty sensible lambda target table. |
| 16:08 | We can see here if we click OK and save those changes into place, we can see that for a lot of the table here, we are targeting lambda one. |
| 16:18 | Obviously good for fuel economy and emissions. |
| 16:21 | Then at higher RPM and higher load, we're dropping a little bit richer so this all makes sense. |
| 16:28 | What we can do now is press escape to close that down. |
| 16:31 | We've got the first of those three tables defined. |
| 16:35 | For the sake of completeness, let's just go ahead and do the same exact process on our reamining two tables. |
| 16:42 | So at the moment we are still viewing in 16 bit mode from when I defined the X axis. |
| 16:47 | So we need to start by switching back into eight bit view, so we'll do that. |
| 16:52 | And let's just scroll down a little bit here so we can get to our second table. |
| 16:58 | Now what we can see is that straight away all of our data doesn't make sense anymore so we need to basically move everything around just like we did until our little table visually makes sense again. |
| 17:13 | And we've done that, everything's looking good so what we can do again, highlight the first of those values, the first 128, everything above this as we already know is our axis data, we'll come back to that. |
| 17:25 | Shift and our right arrow, two, three, four, five, six then our down arrow, one, two, three, four, five, six, seven, eight, nine, 10, 11, 12, 13, 14, 15 that is our table highlighted. |
| 17:39 | K will mark that table, now again we don't have our axis values applied at this stage. |
| 17:45 | Let's press the escape key and again we can see that OLS has found this data down below that it thinks is the next table, press delete to get rid of that for the moment. |
| 17:56 | We're going to define our axes just like we did. |
| 17:59 | Again looking at the data, we've got those same two values, 15 x 6 here, we know that the first digit to the right of those is the beginning of our Y axis, we'll highlight that, right click, come down and click on address as Y axis of the next map. |
| 18:15 | Now we can switch into 16 bit view, first value after our Y axis of course is the start of our X axis, we'll click on that, right click, address at X axis of the start of the next map. |
| 18:32 | So we've now gone ahead and highlighted the X as well as the Y axis. |
| 18:37 | We still need to apply our scaling though and while we can do that manually, it's going to be much faster if we simply copy our map properties from our previous map that we've gone and done that hard work so let's double click on that, bring that up and if we right click here, and we click on copy map properties, that's going to do exactly that. |
| 18:58 | Now in this case, what we want to do is copy our description factor and offset and we want to make sure that we are copying this from the X, Y and map axes. |
| 19:10 | We do not in this case want to copy our data so we'll unclick that. |
| 19:14 | We'll click OK, press escape to close that map, let's double click on our next map. |
| 19:19 | Control V and we can see all of the work is done. |
| 19:23 | So that's two of our three maps now defined. |
| 19:27 | Let's go through and for the sake of completeness, we'll do our third and final one. |
| 19:32 | Let's switch back to eight bit view and what we can see here is that we've actually done this a little bit out of order. |
| 19:40 | Let's go back to 2D and we can see that what I actually managed to do there and no harm no foul, is I've managed to start with the second map instead of starting with the first map so that's why it looks like we don't have a third map in our text view. |
| 19:54 | However if we scroll up, what we're going to find is here's our third map up here. |
| 20:00 | Looks like our alignment is already correct here and again I'm just using the graphical view out here on the right hand side to confirm that. |
| 20:08 | Just to show what it looks like again when it's not right, we use the control and left and right arrow keys, we can sort of see it all falls into place and makes sense when we have it right and we've got that 128 in the top left there. |
| 20:21 | Let's do exactly the same process, we'll hold down the shift key, out to the right, six or five and then down to the last value there which is our 116. |
| 20:34 | Let's press K, that will highlight the map or mark the map I should say, create the map and then we want to go through the same process, so we're looking for our 15 x 6 which we can see right there. |
| 20:46 | First value there we'll highlight that by clicking on it, right click, address at Y axis of the next map, then we'll change over to 16 bit view, first of the values after our Y axis is the start of our X axis. |
| 21:02 | Right click on that, address as X axis of the next map, job is done, let's double click again, we haven't got our scaling applied but control and V and there we go so that's our three driver's requested lambda maps. |
| 21:17 | So here we've gone through a few more processes, we've looked at how we can find axis values in both 16 bit as well as eight bit, how those views differ and then we've looked at how we can also use our text view to manipulate the view, find the map data, highlight the map data and mark the map and then find our axes. |
| 21:40 | Let's now move on and have a look at our next map that we're going to find. |
