WinOLS Mastery: Map Identification & Editing: Step 4: Find and Define Maps
Watch This Course
$299 USD $149.50 USD
-OR-
Or
8 easy payments of only $18.69
Instant access. Easy checkout. No fees.
Step 4: Find and Define Maps
53.40
| 00:00 | - The next step of our process of course, now that we know what tables we're going to need to find and define, is to do exactly that, to find and define those tables within our raw binary file. |
| 00:12 | Now I am going to be cheating ever so slightly with this particular worked example because we are working from the exact same file that we've used within the body of the course, specifically under the finding and defining maps module in the practical skills section. |
| 00:28 | So I'm not going to repeat finding exactly the same maps that you've already seen me find, if you do want a refresher on that, then you can refer to that particular module in the practical skills section and rewatch that but if we jump into our file which I've got open, we can see that in the left hand side here, we've got our driver's relative torque request, we've also got our driver requested lambda tables. |
| 00:55 | We've got our ignition tables and then finally we've found and defined our maximum relative engine load tables. |
| 01:03 | So the only change that I have made from the end of the practical skills module is as you can see, I have assigned these into folders. |
| 01:12 | Now you'll see the process of assigning these into folders as we go through the remainder of this particular module but again you can refer to the practical skills section of the course for a refresher on that process as well. |
| 01:25 | So this has defined a number of the key maps that we're going to need to find. |
| 01:30 | However there's still plenty of work left to do here to give us a map pack essentially that's going to be useful for a stage one calibration. |
| 01:39 | So let's get stuck into finding our remaining maps. |
| 01:43 | The first of these is going to be our KFMIRL map, let's have a quick look at what we're actually looking for in terms of the shape there. |
| 01:52 | So we can see we've got this saw tooth pattern down here and we've also got our axis up here. |
| 02:00 | We can see that in this case it is a 16 bit map and it's a 16 x 12 and we can also see how we want to have OLS set up. |
| 02:12 | Specifically here as usual, we will be 16 bit decimal and the arrangement is high/low so this will be essentially what we're going to be using for finding any map within this particular file. |
| 02:27 | OK now we know that saw tooth pattern that we're looking for, let's jump back into OLS and we'll see if we can find it. |
| 02:34 | Now to start with, we're going to make sure that we are located at the start of the data area and you can see from where the cursor is, we are in fact there. |
| 02:43 | You can choose to adjust the magnification on the X axis if you want. |
| 02:49 | We want enough magnification to be able to see the shape and match it to our picture or image that we've just looked at but of course if we're zoomed in too far, it's going to take a long time in order to find this. |
| 03:02 | What I'm going to do here is right click to the right of our cursor and this will jump one full screen to the right so let's just go through here and see if we can highlight and find that particular map. |
| 03:19 | OK looks like we've got a likely candicate right here. |
| 03:23 | Looks like the right shape, we can head back and have a quick look at our picture again and yep this looks like we've found the correct map. |
| 03:31 | And interestingly we can also see that OLS has actually found this, it's already figured out that this is a likely map so let's go ahead and actually define this properly and we can start by double clicking on it. |
| 03:46 | Now once this table is open we can see we've got essentially completely unscaled values here so nothing really makes a lot of sense right now but let's add some scaling to this. |
| 03:57 | To start with we need to know what the axes are going to be and for that KFMIRL table you'll remember that the axes are going to be RPM and throttle position or driver's accelerator pedal position. |
| 04:09 | The map data or Z axis data is going to be our relative torque request which we know's going to be a number between 0 and 100. |
| 04:18 | Now looking at these numbers here, we look at our Y axis, we can see we've got a maximum number of 26000 there and if we're starting to get familiar with the numbers in the MED controller, this should be obvious as an RPM axis so let's double click on this axis for a start and we'll add our description here as engine speed. |
| 04:41 | Of course the unit for that is in RPM per minute, or revs per minute and then we need to apply our factor or scaling and in the MED controller, typically the axis for RPM will be either multiplied by 0.25 or divided by four, essentially is going to give us the same result so we can enter a value of 0.25, now we can straight away see that everything makes sense, we've got maximum value of 6500 RPM, minimum value of 500 so I'm comfortable that that has correctly defined that particular axis. |
| 05:16 | Alright we've got one axis complete, we know that the other one is going to be our driver's pedal position so let's double click on that and we can enter a description. |
| 05:34 | Of course this time our units is in percentage and again we need to apply some scaling here. |
| 05:41 | So in this case I'm going to use our little function button here and we'll use our formula here and looking at these numbers we can see that the maximum value here is sitting at about 63000 so again we know that this should be a number that's going to reach at or pretty close to 100%. |
| 06:01 | So if we know our logic numbers we might recognise here that a number of 63536 is looking pretty close to this value so let's see how we get on my entering that value there. |
| 06:16 | What I'll do is I'll just drag this window down as well so that we can actually view the whole axis while I'm doing this. |
| 06:22 | So let's enter the value now and see what that gives us. |
| 06:29 | Alright so we can see it's obviously not 65536 but we can see if we have 655, we're pretty close so let's enter a decimal place and we'll add the remainder, 655.36. |
| 06:44 | Now we've got our value of 96% as our accelerator pedal position, we'll click OK here and we may also want to add a little bit of precision here with a couple of decimal places. |
| 06:55 | Let's take that to one, there's actually not much happening there, alright our job's done there, we can click OK. |
| 07:02 | Now we can define our Z axis or map data which is our desired engine load. |
| 07:08 | So we'll double click on this and we can enter the name for the map. |
| 07:20 | With the name, we're going to use the control A to highlight the entire name, control C which will copy it to the clipboard, tab will bring us down to the description and then control V will paste that in there. |
| 07:34 | The relative air charge is a percentage so we'll enter that as our unit and the Bosch acronym for this table as we already know is KFMIRL so let's enter that as well. |
| 07:47 | Alright we've got one last task which is to scale this table, now the factor for this is a specific factor, this comes from the Bosch literature, which is 0.23438. |
| 07:59 | Now this is something that you're not going to necessarily be able to guess, however if we come down to our little function button here and we'll click our output, we know that one of the non logic numbers in our cheat sheet is 42.67 and if we enter that we can see that that actually gives us essentially the same factor there so if you don't remember the actual specific number, also on our cheat sheet, then you can use that factor there. |
| 08:28 | Let's press cancel there, I will enter that correctly and we can click OK and our job is done there. |
| 08:38 | What we're actually going to do though is just add a little bit of precision to our Z axis data as well so let's go in there and we'll add a couple of decimal places as well. |
| 08:46 | Alright our KFMIRL table found and defined. |
| 08:50 | For the sake of completeness though, let's just add it to a folder, even though this will be the only table in that folder. |
| 08:57 | To do that we can come up and highlight the name or hover over the name. |
| 09:01 | We'll click the right mouse button here and we want to come down to copy name. |
| 09:06 | Then what we can do is we can again right click and we're going to click on move into and we want to now click on new folder to create a folder. |
| 09:17 | We've copied the name to the clipboard so control and V will add that as the name of the new folder. |
| 09:24 | And then we can click here, if the name contains the following text, again control V, that's going to copy any subsequent tables, obviously we only have one but it will copy any subsequent tables into that same folder. |
| 09:37 | We'll click apply rule and OK and now we can see we've got desired relative air charger here as a folder. |
| 09:45 | And if we open that folder we can see we've got the one table that we have just defined. |
| 09:52 | Alright let's move on and the next table we're going to find is our KFMIOP, our inverse of KFMIRL. |
| 10:00 | Looking at the sample screenshot we've got of our KFMIOP, we can see we've got a really obvious structure to this particular table here, shouldn't be too difficult to find and we can see we've got our axis here to the left, we can see that this particular table is a 16 x 11. |
| 10:19 | So let's head back into WinOLS and we'll search through and see if we can find this particular pattern. |
| 10:27 | In order to start searching for our new pattern, we can close down our KFMIRL table and before we do this, I will just show you that if you want to switch the axes around, we can come up to the top right hand corner, right click there and we can choose the swap axis plus map option. |
| 10:46 | Really important when we do this that we use this option, otherwise the map data won't be transposed and we'll end up with essentially garbage so we'll click on that and this is probably the more common way that we would actually view this table. |
| 11:00 | Let's press escape to close that down and we are located partway through our axis here and when we're going through and finding these potentially out of order, we might not necessarily know which way we actually have to scroll so we may go in one direction, can't find that map and go back in the other direction but that's all part of this process. |
| 11:20 | In this case, I'm going to start by clicking to the right here and we'll see if we can find that shape. |
| 11:31 | And it looks like we've found that relatively quickly right here. |
| 11:35 | Let's just get that into the centre of our screen. |
| 11:39 | We can zoom in a little bit more on that and we can also compare it to our screenshot. |
| 11:45 | Yep that's looking like we've found the correct table so again let's double click on that to turn it into a table and now we can go through the process of defining it. |
| 11:56 | Alright so straight away we can see that the Y axis is exactly the same as what we've just defined so we should be noticing this straight away as engine RPM so let's just enter that now. |
| 12:15 | OK job done there, went through that a little bit faster, we already know that our scaling factor for RPM there is multiplied by 0.25 or divide by four. |
| 12:23 | The X axis in this case, let's double click on this and remembering this is the inverse of the last table KFMIOP so KFMIOP, the map or Z axis data is our relative cylinder fill so that becomes our, in this case, the X axis here so let's enter that. |
| 12:58 | Again as per our last table, we know that the scaling factor for this is 0.023438 and there we go. |
| 13:07 | We again can add a little bit more precision to this as required. |
| 13:11 | Let's click OK and finally we've got our Z axis or map data, remembering this now, because it's the inverse table, this will be our relative torque request so let's double click on that. |
| 13:22 | Relative torque request here, we know that we're going to be looking at numbers between 0-100. |
| 13:30 | Let's enter our map name first though. |
| 13:40 | Values for this axis of course use the unit of percent and we can enter the ID for this which is KFMIOP. |
| 13:49 | Now we need to enter our scaling here and let's click on our little function button and we will click on our output radio button, let's enter 655.36 and see how we get on there and yep we've got numbers that look like they're in the right range there and remembering we can simply move that decimal place around as required, let's just see how that would work, 65536 obviously isn't going to work, we'll move our decimal place to the left one spot and obviously now we're looking at values in the region of 900 maximum so we know that our decimal place is in the wrong spot, let's put it back where it belongs, we'll click OK there and again we may want to add a little bit of precision to this as well. |
| 14:37 | Let's click OK, our job's done there but we will also add this to a folder. |
| 14:43 | So again same process here, we'll right click, we will copy the name, we'll right click again, go down to move into, we will click on new folder, control V to add that name that we just copied, and then we can copy this down here as well, we'll apply that rule and click OK. |
| 15:04 | And our job is done there. |
| 15:06 | We've now got our desired relative air charge table in its own folder. |
| 15:11 | Let's press escape here, we'll close that down and we can move on and find our next table. |
| 15:17 | Next up we're going to define our lambda tables and we've already defined our driver's wish or driver's requested lambda tables, we need to find our lambda for component protection tables. |
| 15:28 | So let's have a look at our screenshot here and this is the pattern we're going to be looking for. |
| 15:34 | We know that this is a 16 x 12 table in eight bit arrangement. |
| 15:40 | Pretty obvious pattern and we can also see that this pattern repeats as well so we know we've got multiple tables. |
| 15:47 | There's almost certainly one off to the right here as well. |
| 15:50 | Another important element to note from this screenshot is we can see that we don't have the axis located directly before or actually directly after this and we don't have an axis for each of these tables so all of the tables will be sharing the same axis, we do need to find that axis. |
| 16:07 | Important to note there that despite this screenshot showing an arrangement of 16 bit, we will want to actually be searching in eight bit. |
| 16:16 | Always worth mentioning here that if you simply click on the table that is already highlighted, the OLS setup will be configured to suit, in this case eight bit. |
| 16:28 | Alright let's head back into OLS and we'll see if we can find that particular table. |
| 16:33 | Now again we don't necessarily know when we're just getting started whether we'll be to the left or the right of our current location, we can see that we are a little ways into our calibration data area but I know that we're actually to the right in this case so we're going to continue searching in that direction. |
| 16:51 | Of course if you don't know, you'll go to one end of the calibration data and you may have to start again at the beginning so let's just click through looking for that particular pattern. |
| 17:00 | What I will do is just shrink down our X axis magnification, we will change to our eight bit arrangement as well so let's see if we can find that. |
| 17:12 | And looks like that's our data area there, let's just give that a little bit more of a zoom so we've got a bit more detail visible. |
| 17:22 | And what we can also do there is just give ourselves one more comparison back to our screenshot, it's all looking pretty much the same there so we know we've found the right spot. |
| 17:35 | Now as I mentioned, we don't have the axis values to the left and in this case the actual axis values are to the right of our data area, our map area but not directly to the right so this is something where really understanding this will require use of a description file but once you know where this is located, it is something that we will be able to find, I'll just take you through to that particular area of the map now. |
| 18:06 | So the actual axis data is in this area here so not exactly intuitive I'll admit, we'll get into this and we'll see how we can actually use that data but let's just scroll back to start with and we can find and define our first of these tables. |
| 18:24 | What I'm going to do is just click somewhere to the right of the table data here, doesn't have to be too accurate, and we'll switch to our text view. |
| 18:33 | As we come into this text view, it's important to understand what our width setting is. |
| 18:38 | At the moment this is set to 15 and what we're doing is using the graphical representation over here on the right to help guide us. |
| 18:47 | So what I'm going to do is just start shrinking this down and we're looking for that pattern to start forming, so as I shrink this down, we can see we've got this line running through here, it repeats up here, we want to adjust our width until that line becomes vertical. |
| 19:04 | So let's just press the W key one more time and it jumps into an order so we can see now everything is nicely ordered. |
| 19:11 | I've also fluked it here that the actual alignment is correct. |
| 19:15 | That's not usually going to be the case so I'll just hold down the control key and I use the left and right arrow keys, probably chances are that when you get the width correct, it's going to end up looking like a pattern like this and straight away I'm looking at this vertical line here of that pattern and I know that that shouldn't be in the middle. |
| 19:36 | Basically our pattern starts small, jumps up and then drops down again. |
| 19:39 | Obviously that doesn't make much sense. |
| 19:41 | If I hold down the control key and I press the right arrow key, we scroll that across, we can see that at that position, everything jumps into order and now our pattern looks like it makes a bit of sense. |
| 19:54 | Now we can also see, in terms of finding the table size, we can also see that this pattern does repeat so if I highlight the pattern that I'm interested in here, this is our table here and that just repeats again right here and obviously again above it. |
| 20:11 | So what we'll do is we'll highlight the values in this table here and we'll go across to the right and we'll come down to the bottom here. |
| 20:22 | And we can see that this is a 12 x 16 table, that should match what we've already found with our screenshot. |
| 20:32 | Let's press the K key to mark that table and there we go. |
| 20:38 | Now we want to first of all start by scaling our map axis data so let's double click on our map data and we can give this table a name for a start. |
| 20:49 | So we know this is going to be lambda for component protection. |
| 21:00 | Control A, control C, tab and control V will paste that down. |
| 21:07 | And our units for this of course are lambda. |
| 21:10 | Now we need to apply our scaling. |
| 21:14 | We know that for lambda typically we're looking at a value of 128. |
| 21:18 | We can see that we do have some 128s in this table so let's go ahead and apply our scaling there, we'll use our little function button and we're going to click on our output radio button, scroll this down, or move this out of the way so we can see what's happening there. |
| 21:36 | I'll enter a value of 128, that does get us to values of one so we'll click OK and then we'll add a little bit of precision here, couple of decimal places and we can see now we've got a table that actually makes sense in terms of lambda values and we can see also with our component protection values, they are very rich, obviously using the fuel there to help reduce the combustion charge temperature. |
| 22:04 | Alright we've got our first table defined in terms of our map values but we don't have our axis values so we know that this is a 12 x 16 table. |
| 22:15 | Let's click OK here, we'll press escape to close that table down and we'll press delete to unmark it, let's go back to our 2D view and we'll scroll across and find our axis values. |
| 22:31 | Aright so this is the area where I know these axis values are, I've just put the cursor essentially in the middle there. |
| 22:39 | What we can now do is switch to our text view and we'll have a look at these values. |
| 22:44 | Let's just scroll up a little bit so we've got a better idea of where everything is and what we're looking for here is the values 12 and the value 16. |
| 22:54 | These represent the size of the axis and you can see, there is a value right here which is just above where I put my cursor with the value of 16. |
| 23:05 | So the first number after this should be the first value in our axis, let's just increase our width at the moment to 16 and what we'll do is we'll arrange this so that our axis is starting on the left hand side. |
| 23:21 | And what we can see is that with the axis arranged like that, graphically everything looks like it is correct. |
| 23:29 | So what we can do here is come to that first value, we can right click on it and click copy address. |
| 23:34 | Let's come back to our lambda for component protection table and we know that the value that we just copied was our 16 axis so that is in this case our Y axis. |
| 23:46 | Let's go to our data source. |
| 23:49 | In this case we want to select EEPROM, start address, control V will copy that value from the clipboard that we just copied and now we've got numbers that look like they're probably about right, they at least follow a nice sensible order. |
| 24:05 | In this case our Y axis is our engine speed so let's enter that now. |
| 24:15 | Interestingly the factor that we've been using so far for our engine speed is to multiply by 0.25 or divide by four. |
| 24:24 | In this case we're using eight bit for engine speed, the multiplication factor for this actually ends up being 40 and that's another one of our known values that you'll find on our cheat sheet, we've now got our RPM scale from 600 out to 6500 so we know that we've got that correct. |
| 24:41 | Let's click OK, now we need to locate our X axis and in this case we know that this is a 0-11 so we know that this is a 12 wide table, let's press escape, get back out of that and what I'll do is we'll scroll back over to the axis area. |
| 25:00 | Alright so on our screen at the moment we can see this area here which we just found for our Y axis and it's typical that we're going to expect to find our X axis values pretty close by so let's just put our cursor on the axis to the right here and what I'm looking for here is the number to the right of our cursor here. |
| 25:22 | So as I scroll down, what we're looking at is that number, we're looking for, hopefully a number of 12 which we've got to there so remembering this means that the axis is 12 values from here so the first value to the right will be our axis value so let's just have a look at this in text view. |
| 25:41 | We'll do exactly the same so we've still got our value 12 highlighted. |
| 25:46 | Now this is 12 wide, we currently have our OLS table set up with a width of 16 so let's just shrink that down by pressing the W key and now we'll just use our control and arrow keys so that the first value on the left hand side is actually our data and that is right there and we can see we've got a nice sensible shape to our table there. |
| 26:10 | So what we can do is right click here and what we can do is actually go straight down here to address at X axis of the previous map. |
| 26:21 | So that should give us our map, let's go and have a look at that map now. |
| 26:27 | OK so we've got our axis now displayed, we can double click on this and this axis for our lambda for component protection table is our relative cylinder fill so let's enter that. |
| 26:43 | Of course the unit for this is percent and this time we are eight bit, the factor for this one is 0.75 or multiplied by 0.75 and that, we can see now spans us up to 170, you can also give it a little bit of precision there with a couple of decimal places and our job's done. |
| 27:05 | So we've now got the first of our lambda for component protection tables found and defined. |
| 27:12 | What we can do now is right click inside of the table and we're going to copy the map properties. |
| 27:17 | Now this time what we want to do is make sure that we're copying the properties for those axes that we've just found and defined, remembering that the same address is used for the axes for each of the tables. |
| 27:31 | So to do that, on the left hand side we want to make sure that for our description we're copying our name, description, ID, units, factor, offset etc and we want to make sure that we are doing that for the X, Y and Z axes. |
| 27:45 | We also want to come over here to our data area and we want to tick this little box here for data source plus address. |
| 27:54 | And we want to do this only for our X and Y axis values so this will then copy the address for those from this current table, we'll be able to paste that into our subsequent table. |
| 28:07 | So let's click OK, let's close this table down by pressing escape and we'll now define the remaining tables. |
| 28:14 | Now you can see here that the table that we have defined, you'll remember this was the last of those tables and the reason we've done that is because the axis values were located just after this table. |
| 28:25 | What we'll actually do now is scroll back up and we'll find the first of these tables. |
| 28:30 | We can either do it in this text view here, very easy to see because we've got this same pattern that just continually repeats here. |
| 28:38 | So we can use that to guide us. |
| 28:40 | And by starting at the top here, what we're going to do hopefully OLS will actually note that there's a repeating pattern and it will automatically highlight the next table in order so let's see how that works. |
| 28:53 | What we're looking for here is the pattern shape which I've just highlighted and we know, we can confirm with our previous table that we have defined, we can see that the top left value there is 154, if we look above this, the key to know where the next table starts is that the numbers above are much lower, remembering that this is our high/low, high RPM area where it's targeting much richer lambda numbers. |
| 29:18 | So we're just repeating that process there, that pattern so we'll scroll back up here and 154 here, so what we want to do is highlight across 12 or 11 more, one, two, three, four, five, six, seven, eight, nine, 10, 11 and then remembering we're 12 x 16 so we're going to come down a further 15 so one, two, three, four, five, six, seven, eight, nine, 10, 11, 12, 13, 14, 15 and 16, that is our table there, we'll mark that by pressing the K key. |
| 29:48 | We've got our table found there, control V will apply our scaling and our axes. |
| 29:55 | You can see that has done exactly that. |
| 29:57 | Escape will close that down. |
| 29:59 | Now what we can see is that OLS has in fact found and marked correctly this time the next table so that's why I wanted to scroll back up and start at the start there. |
| 30:08 | So again we can press the K key, this marks the next map, control V will paste in our information, our map properties, escape will close that down and again we can see that OLS has jumped ahead so I'll just now repeat this process, we'll speed it up and we'll mark the remaining tables. |
| 30:30 | Alright so we've got all six of our lambda for component protection tables found and correctly defined but we do want to also put these into a folder so let's go ahead and do that. |
| 30:40 | We'll right click and go down to copy name then we'll right click again, we're going to go down to move into, we're going to create a new folder, control V will paste that name for the folder and then we want to also select this section here, so that's going to apply that, click OK and OK and now we'll be able to see that we have a folder created for our lambda for component protection, that is right here, expand that out, you can see we've got our six tables already located inside of that folder. |
| 31:18 | So let's move on and we'll deal with our next set of tables. |
| 31:21 | The next table we're going to find is our MAF correction or linearisation table and if we jump across to my laptop, this is a screenshot sample of what this particularly table is going to look like so this is the trend we've got for the table. |
| 31:36 | Not a lot going on there, we can see we've also got the axes located out to he left hand side there. |
| 31:41 | Noting that this is a 14 x 14 table and it is eight bit so let's jump back into OLS and we'll go ahead and see if we can find that. |
| 31:52 | Now the same advice always goes here, we don't necessarily know or wouldn't necessarily know if we are going to be looking for a table to the left or the right of the cursor. |
| 32:02 | In this case, I know where the address is so I'm going to speed this up because I know that we're going to be looking to the left of where we currently are so we'll just start clicking to the left here and see how far we have to go before we can find that particular table. |
| 32:21 | Alright and we've found the table there, this is the shape that we're looking for. |
| 32:26 | Now obviously we are zoomed out a little bit, we've got our magnification for our X axis at 100%, let's just zoom in a little bit and we'll get our table into view. |
| 32:37 | And we'll just confirm this against our screenshot just to make sure we are looking at the right table, though I'm pretty confident that is the one that we want. |
| 32:47 | Just get it back into the centre of our screen first and we can see that OLS has actually already found and highlighted this table, we can see it's found it, 14 x 14, eight bit, which matches what we saw in our screenshot, let's have a quick look again. |
| 33:03 | Yep everything is looking correct so we know that is our table there. |
| 33:08 | Let's head back to OLS and we can now define that. |
| 33:12 | Now what we're going to do here, because OLS has actually already found this table, we can just open this up in text view and obviously we just need to apply our scaling information to this. |
| 33:22 | So what are we looking at here? Well for a start, the numbers in this table are going to be a correction factor. |
| 33:30 | Looking at the numbers in here in the Z axis, the map data, you can see values around 128 which probably is going to be a hint that we're going to be wanting to divide by 128. |
| 33:43 | Let's start by double clicking on the map data and hopefully at this stage, you've already noticed that the numbers in this table are at or quite close to 128, 128 being one of our binary number sequences and we know that this is going to come into play with our factor. |
| 33:59 | Before we get to that though, we need to give the table a name and we're going to call this MAF correction map so let's do that. |
| 34:10 | And we can use control A to highlight all of that, control C to copy, tab to come down to our description field, control V will paste that in. |
| 34:20 | Units for this, we're going to be in percent. |
| 34:25 | Let's come down to our factors and we're going to as usual click on our little function button here and we'll click on the output here, let's move this out of the way just so we can see what happens to our table values and we'll divide by 128 and of course with no precision, everything goes to a value of one. |
| 34:42 | Let's click OK there and give it a couple of places of precision, now we've got a map that actually looks like it makes a bit of sense. |
| 34:50 | Now the way this map works is a number of 1.00 has no effect on the MAF characteristic or calibration, numbers less than one of course remove and numbers greater than one will be adding to so we've got the map data now defined correctly. |
| 35:07 | Now we know that the axes for this table will be engine speed and relative load, relative cylinder fill so looking at the axes here, this one here that goes out to 163, this is most likely going to be our engine speed so we'll double click on this and let's just try this, one of the factors that we know that Bosch use for engine speed is multiplying by a factor of 40, we do that and we can see yes that gives us our RPM. |
| 35:33 | Remembering this is eight bit as well, this is why there's some differences in the factors that Bosch use so let's give this a description and unit now. |
| 35:43 | That leaves us with our other axis, we can double click on our X axis here, we know that this is going to be relative cylinder fill so we'll enter that. |
| 35:54 | And we know that the units for this of course are percent. |
| 35:58 | The factor for this particular table is that we can multiply by 0.75, that gives us our axis running out to we can see 171%, we'll give it a little bit more precision as well, click OK and our job's done there, first of those tables has been correctly defined. |
| 36:16 | Alright so at this stage we've got our map found and correctly defined, scaled, etc, we can press escape to close that down, delete to unmark that section and let's move onto our last tables now, our wastegate control tables. |
| 36:32 | Alright there's two tables that we're going to need to find here, the first of these is referred to as the wastegate feed forward table, which is essentially the base duty cycle and there's another table we'll look at immediately after which is essentially the maximum duty cycle that will be allowable. |
| 36:48 | So this screenshot here shows us the first of these, our feed forward table, we can see that it is a 16 x 8 table in 16 bit and this is the general shape that we are looking for here. |
| 37:00 | Let's head back to OLS and we'll see if we can go ahead and find that. |
| 37:05 | As usual, we don't necessarily know where abouts this next map is going to be but if we have a look at our cursor down here we can see we're essentially right at the beginning of our calibration data area, so there's a pretty good chance that we are going to be somewhere to the right so let's scroll through and see what we can find here. |
| 37:24 | What I'll do as well, I'll just bring down our magnification a little bit just to make this a little bit easier to view quickly, so let's go ahead now and see what we can find. |
| 37:38 | OK here is the shape that we're looking for so it's actually twofold, we've got the shape of our wastegate feed forward table right here and then to the right of it, this is our second map that we will be looking for which is our maximum duty cycle often referred to as wastegate duty cycle linearisation table. |
| 37:59 | So let's go ahead and define these now. |
| 38:02 | One of the tricky parts with these two maps is that the axes are really nowhere relevant to the maps themselves and as we can see there's nothing there in the close proximity that has the shape or look of an axis that's going to be useful for these tables and they are actually, the axes are located quite remotely, these aren't axes that you're going to be able to just randomly stumble upon, this does require access to a description file in order to find them. |
| 38:32 | So this is going to present a problem if you don't know where they are and you don't have that description file, however I will just point out that finding and defining these two tables is not strictly necessary at a stage one level. |
| 38:46 | Realistically you're still going to be able to raise and manipulate the boost without actually adjusting these tables. |
| 38:53 | These tables become more important when you really want to start leaning on the boost pressure or potentially you've made some changes to the wastegate or the turbocharger. |
| 39:02 | Let's get into this anyway and what we want to do is understand where the data actually lies and what we can find here is that this essentially represents the wastegate feed forward table and the part here to the left, these high sections which will represent as we'll find out, 100% duty cycle, these are actually currently being displayed as a potential map here, which is what I've just highlighted. |
| 39:32 | So what we need to do is actually delete this potential map. |
| 39:35 | So let's right click on that and we'll click on delete potential map, it'll get rid of that map so that we can actually go ahead and define the map that we're interested in. |
| 39:47 | Let's switch to our text view here and we can see the particular address that we have highlighted there is flashing right there so again what we want to do is start by just adjusting our width to get our alignment correct and as usual what we're looking at is the shape of these lines here, we want to get these straight and we're looking at the moment our width is set to 11 so what we'll do is we'll shrink this down and we've actually got two different tables here of course, we can see that as I shrunk that down to a width of 10, this table here pops into alignment but that's not the one that we're currently interested in, we can see that the one that I've got highlighted, we've still got this angle so let's just shrink that down again, come down to nine, come down to eight, so eight we can see that our table now does look like it makes a bit of sense so that's a good sign for us. |
| 40:44 | So what we know is our width there is eight. |
| 40:47 | From my own knowledge of this, we also know that this table is going to be an 8 x 16 so let's have a look at how that works out. |
| 40:55 | So we will just hold down the shift key and right arrow out until we've highlighted a width of eight and then we'll come down 16, so one, two, three, four, five, six, seven, eight, nine, 10, 11, 12, 13, 14, 15 and 16. |
| 41:09 | Now it can be tempting here to also look and graphically this next line also looks like it's very similar but what we can see is that the pattern doesn't actually follow through. |
| 41:20 | We've got all of these zeros here, those will represent low load, mid RPM, as the RPM comes up we can see that we're getting values of 1000 and 2000 so we're starting to climb and if we had highlighted that next row, we can see that we drop back to zero so it doesn't actually follow that pattern so that's a little hint there. |
| 41:40 | Plus we're 16 x 8, we're not going to have a table that is 17 x 8 so we can press K to mark that particular table. |
| 41:50 | Now that has a little box here that's popped up, it's said that directly in front of the map data was found data that might be axis data, in this case it absolutely is not so we're going to click no to that. |
| 42:03 | Don't worry, OLS, we've got this under control. |
| 42:06 | So now we've got our data but of course no axis data. |
| 42:10 | The numbers in this table represent wastegate duty cycle so we're looking at numbers between zero and 100%. |
| 42:19 | However it's unlikely we will actually see a number of 100 in this table so we need to apply some scaling to this. |
| 42:27 | Let's double click on the map and we can do exactly that. |
| 42:31 | First of all we want to give the table a name and this is known as the wastegate feed forward table so let's enter that. |
| 42:39 | Now we'll use the control A function, control C to copy, tab and control V, that will paste that into the description, of course the units for this are percent. |
| 42:50 | The factor for the conversion here is again not one that you're necessarily going to guess, Bosch use a factor of 0.005 for this, let's enter that now and we can see, now we've got numbers that sit at a maximum of 95%. |
| 43:07 | So again within the realms of what we'd expect, let's just add one decimal place of precision to that as well, we can click OK, that's going to shut down our map. |
| 43:19 | Now we've got our axes defined and we've got one axis here that's going to be engine speed and the other axis is going to be our target relative charge pressure. |
| 43:29 | So the axis that is 16 wide, that one that I've just clicked on here, our Y axis, this is going to be our engine speed so let's enter that. |
| 43:41 | As I mentioned, you're not going to be able to just stumble upon the address for this, it does come from a description file, I can show you inside of the file in 2D as we've seen before where this particular axis exists but it's really not going to help you so I'm just going to directly enter the address here, so we're going to change this to, from EEPROM. |
| 44:04 | And the address for this axis is 1C88DC. |
| 44:11 | Now what we've seen is some numbers have popped up but these definitely don't look like they're going to help us. |
| 44:17 | That however is because the data organisation at the moment is 32 bit high/low, which is absolutely not what this is, this will be a 16 bit high/low, change that, straight away we've got some numbers that now look a little bit more sensible and again as is typical in this controller, values around 26000 are a really good hint that we're looking at RPM, we already know that the factor for this is going to probably be a multiplication by 0.25 or divide by four so let's apply that scaling now. |
| 44:53 | Alright now we've got our axis out to 6500, that's looking good. |
| 44:57 | I will just add the units in here in RPM and we can click OK. |
| 45:02 | That's our RPM axis defined, our next axis there, remember this is our target relative charge pressure and we'll double click on that, we can enter that name for our description. |
| 45:20 | The units in this case is hectopascals so we'll enter that. |
| 45:25 | The data source here is of course coming from our EEPROM and then the start address so again not going to guess this but we know what this start address is and in this case it is 1CFA4C. |
| 45:42 | And we've got again some pretty interesting numbers that have popped up but exactly the same problem here, we can see that our data organisation has defaulted to 32 bit high/low, let's just change that back to 16 high/low and now we've got some numbers that look like they could be workable. |
| 46:01 | Looking at the maximum value there, 256000, and 256 is one of our factors so let's see how we can utilise that. |
| 46:12 | We'll click on our little function button and what we're going to do is just drag this down so we can see the entire axis and I'm going to divide by 256 and see what we get, value here of 100 maximum so when we're dealing in hectopascals, looks like our factor is out by a factor of 10 so let's try 25.6, now we've got a axis that goes from 100 through to 1000 so about what I'd be expecting there, click OK and we've got that table defined. |
| 46:45 | Now with this table I would typically view it with the axes inverted so we can right click and swap our axis plus our map and now we've got a map that looks a little bit more sensible, we can also view this in 3D and visually this is what we'd expect from the shape of a wastegate feed forward or basic duty cycle table. |
| 47:08 | So we've got one of our maps defined now, let's just press escape to close this down and we can now look for our linearisation table. |
| 47:17 | As I close this down we can see that again OLS is being super helpful and deciding that the data directly below looks like it might be another map, well it is another map but the organisation is a little bit different so we're going to press delete and get rid of that map. |
| 47:33 | Now what we can see is that the alignment for the data that we've just created and map that we've just created looks good but the data directly below which we now know is for our wastegate linearisation table, this obviously isn't correct so what this means is the table size is different. |
| 47:52 | So let's just use our W and M keys in order to get our data aligned and in this case I already know that we're actually going to want to increase our width so I'll press the M key, you can see that our lines here, getting close so we're going in the right direction, press the M key one more time, so now with a width of 10, we now have our alignment correct, we've got this nice vertical line. |
| 48:18 | However we still need to actually move things along so you hold down the control key and we'll use our right arrow key to get the alignment of our table correct. |
| 48:29 | So now we've got our table aligned correctly and we can start here, top left corner and we're going to highlight out to the right so this axis of course is 10 wide so, one, two, three, four, five, six, seven, eight, nine, 10 and we'll come down to the bottom of this data. |
| 48:48 | So one, two, three, four, five, six, seven, eight, nine, 10, 11, 12, 13, 14, 15 and 16 so our table is highlighted, press the K key and we'll create that table. |
| 49:00 | Now the numbers inside of this table are again duty cycle values so let's double click on the map data and we're going to give this map a name, we're going to call this a wastegate linearisation. |
| 49:18 | Now the units for this again are percentage, this is a duty cycle and the value here, the factor that we're going to enter is exactly the same as for our last table so you might remember that is 0.005, we've now got a wastegate duty cycle value, we'll give it one point of precision here an we can close that down. |
| 49:38 | We've now got our X and Y axes to deal with so let's double click for a start on our Y axis, we know that this one is an axis that is 16 long. |
| 49:48 | Most likely it's going to be exactly the same as our last one which is engine RPM. |
| 49:53 | Again the addresses you're not going to be able to guess but we already know these so let's go ahead and enter our information. |
| 50:05 | Alright we've go our axis now making sense, 4000 out to 26000, again the same conversion factor, 0.25 and we've got our engine speed, let's close that down. |
| 50:16 | Let's now do the other axis, our X axis here, we'll double click on this and again you're going to need some information on what this axis is from a description file, this is referred to as the duty cycle from controller so we'll enter that. |
| 50:34 | This is of course a duty cycle so it is a percentage, again we know from our description file where abouts in the EEPROM well find this and the specific address for this is 1CFA5E. |
| 50:49 | So we've got numbers running up to 19000 which where the same numbers that we had inside of our table so we're going to use the exact same conversion factor, 0.005 and there we go, zero through to 95% and if you're feeling fussy, we can add another point of precision there. |
| 51:10 | Alright so we've got our two wastegate tables defined, we can press escape to close that down. |
| 51:16 | Again OLS is trying to tell us there's another table just directly beneath which there absolutely is not so we'll press escape and remove that area that has been marked. |
| 51:26 | Now what we want to do is just clean up a little bit, we've found all of the maps that we want to use but we haven't added these last two or for that matter our MAF correction map into folders so let's go ahead and do this. |
| 51:40 | Let's start with our MAF correction map, so we'll right click on the name of that, we'll click on copy name, we'll come back, right click on that and click move into and we're going to create a new folder. |
| 51:53 | We'll just give it the same name and then we'll click on this little box here, add the name again, apply that rule, click OK and OK and that has created our new folder for our MAF correction map and we can see that is visible right there. |
| 52:10 | Obviously not essential to move it into its own folder when there is only one table like this but for the sake of completeness and making everything look neat and tidy and very easy to navigate, this is a good practice to get into. |
| 52:24 | Let's do the same for our wastegate linearisation and feed forward. |
| 52:28 | So again we can right click here, now copying the name, useful to a point here but let's just do that and what we're going to do is now right click again and we're going to click move into, we're going to click new folder and this time the name, we're going to give this the name of wastegate control. |
| 52:52 | In this case, if the name contains the following text, we can do this because we did just copy and paste, so we'll apply that, that's going to move one of our two tables into that new folder but it leaves our wastegate linearisation table or map out of it, of course it didn't have the same name so it's not going to jump into that. |
| 53:12 | So what we could do is right click here and move into and we've got our wastegate control folder already highlighted here, we'll click OK, job done. |
| 53:23 | So at this point we have found and defined all of the maps that we're going to need for our stage one calibration, we're ready to move on with the next step of our process. |
