FreeEMS: tableLookup.c Source File

00001 /* FreeEMS - the open source engine management system
00002  *
00003  * Copyright 2008, 2009 Fred Cooke
00004  *
00005  * This file is part of the FreeEMS project.
00006  *
00007  * FreeEMS software is free software: you can redistribute it and/or modify
00008  * it under the terms of the GNU General Public License as published by
00009  * the Free Software Foundation, either version 3 of the License, or
00010  * (at your option) any later version.
00011  *
00012  * FreeEMS software is distributed in the hope that it will be useful,
00013  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00014  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00015  * GNU General Public License for more details.
00016  *
00017  * You should have received a copy of the GNU General Public License
00018  * along with any FreeEMS software.  If not, see http://www.gnu.org/licenses/
00019  *
00020  * We ask that if you make any changes to this file you email them upstream to
00021  * us at admin(at)diyefi(dot)org or, even better, fork the code on github.com!
00022  *
00023  * Thank you for choosing FreeEMS to run your engine!
00024  */
00025 
00026 
00037 #define TABLELOOKUP_C
00038 #include "inc/freeEMS.h"
00039 #include "inc/commsISRs.h"
00040 #include "inc/tableLookup.h"
00041 
00042 
00043 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
00044 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
00045 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& ******* ******* ******* &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
00046 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& ******* WARNING ******* &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
00047 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& ******* ******* ******* &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
00048 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
00049 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
00050 /*&&&&&&&&&&&&&&&&&&&&                                                               &&&&&&&&&&&&&&&&&&&*/
00051 /*&&&&&&&&&&&&&&&&&&&& These routines rely on the fact that there are no ISRs trying &&&&&&&&&&&&&&&&&&&*/
00052 /*&&&&&&&&&&&&&&&&&&&& to access the small tables and other live settings in the ram &&&&&&&&&&&&&&&&&&&*/
00053 /*&&&&&&&&&&&&&&&&&&&& window as specified by the RPAGE value. If they are then bad  &&&&&&&&&&&&&&&&&&&*/
00054 /*&&&&&&&&&&&&&&&&&&&& values WILL be occasionally read from random parts of the big &&&&&&&&&&&&&&&&&&&*/
00055 /*&&&&&&&&&&&&&&&&&&&& tables instead of the correct place. If that occurs it WILL   &&&&&&&&&&&&&&&&&&&*/
00056 /*&&&&&&&&&&&&&&&&&&&& cause unpredictable and VERY hard to find bugs!!              &&&&&&&&&&&&&&&&&&&*/
00057 /*&&&&&&&&&&&&&&&&&&&&                                                               &&&&&&&&&&&&&&&&&&&*/
00058 /*&&&&&&&&&&&&&&&&&&&&  *******  *******  YOU HAVE BEEN WARNED!!!  *******  *******  &&&&&&&&&&&&&&&&&&&*/
00059 /*&&&&&&&&&&&&&&&&&&&&                                                               &&&&&&&&&&&&&&&&&&&*/
00060 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
00061 /*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*/
00062 
00063 
00064 /* Yet to be implemented :
00065 
00066 unsigned char lookup8Bit3dUC(
00067 unsigned short lookup16Bit2dUS(
00068 unsigned char lookup8Bit2dUC(
00069 signed short lookup16Bit3dSS(
00070 signed short lookup16Bit3dSS(
00071 signed char lookup8Bit3D( */
00072 
00073 
00113 unsigned short lookupPagedMainTableCellValue(mainTable* Table, unsigned short realRPM, unsigned short realLoad, unsigned char RAMPage){
00114 
00115     /* Save the RPAGE value for restoration and switch pages. */
00116     unsigned char oldRPage = RPAGE;
00117     RPAGE = RAMPage;
00118 
00119     /* Find the bounding axis values and indices for RPM */
00120     unsigned char lowRPMIndex = 0;
00121     unsigned char highRPMIndex = Table->RPMLength - 1;
00122     /* If never set in the loop, low value will equal high value and will be on the edge of the map */
00123     unsigned short lowRPMValue = Table->RPM[0];
00124     unsigned short highRPMValue = Table->RPM[Table->RPMLength -1];
00125 
00126     unsigned char RPMIndex;
00127     for(RPMIndex=0;RPMIndex<Table->RPMLength;RPMIndex++){
00128         if(Table->RPM[RPMIndex] < realRPM){
00129             lowRPMValue = Table->RPM[RPMIndex];
00130             lowRPMIndex = RPMIndex;
00131         }else if(Table->RPM[RPMIndex] > realRPM){
00132             highRPMValue = Table->RPM[RPMIndex];
00133             highRPMIndex = RPMIndex;
00134             break;
00135         }else if(Table->RPM[RPMIndex] == realRPM){
00136             lowRPMValue = Table->RPM[RPMIndex];
00137             highRPMValue = Table->RPM[RPMIndex];
00138             lowRPMIndex = RPMIndex;
00139             highRPMIndex = RPMIndex;
00140             break;
00141         }
00142     }
00143 
00144     /* Find the bounding cell values and indices for Load */
00145     unsigned char lowLoadIndex = 0;
00146     unsigned char highLoadIndex = Table->LoadLength -1;
00147     /* If never set in the loop, low value will equal high value and will be on the edge of the map */
00148     unsigned short lowLoadValue = Table->Load[0];
00149     unsigned short highLoadValue = Table->Load[Table->LoadLength -1];
00150 
00151     unsigned char LoadIndex;
00152     for(LoadIndex=0;LoadIndex<Table->LoadLength;LoadIndex++){
00153         if(Table->Load[LoadIndex] < realLoad){
00154             lowLoadValue = Table->Load[LoadIndex];
00155             lowLoadIndex = LoadIndex;
00156         }else if(Table->Load[LoadIndex] > realLoad){
00157             highLoadValue = Table->Load[LoadIndex];
00158             highLoadIndex = LoadIndex;
00159             break;
00160         }else if(Table->Load[LoadIndex] == realLoad){
00161             lowLoadValue = Table->Load[LoadIndex];
00162             highLoadValue = Table->Load[LoadIndex];
00163             lowLoadIndex = LoadIndex;
00164             highLoadIndex = LoadIndex;
00165             break;
00166         }
00167     }
00168 
00169     /* Obtain the four corners surrounding the spot of interest */
00170     unsigned short lowRPMLowLoad = Table->Table[(Table->LoadLength * lowRPMIndex) + lowLoadIndex];
00171     unsigned short lowRPMHighLoad = Table->Table[(Table->LoadLength * lowRPMIndex) + highLoadIndex];
00172     unsigned short highRPMLowLoad = Table->Table[(Table->LoadLength * highRPMIndex) + lowLoadIndex];
00173     unsigned short highRPMHighLoad = Table->Table[(Table->LoadLength * highRPMIndex) + highLoadIndex];
00174 
00175     /* Restore the ram page before doing the math */
00176     RPAGE = oldRPage;
00177 
00178     /* Find the two side values to interpolate between by interpolation */
00179     unsigned short lowRPMIntLoad = lowRPMLowLoad + (((signed long)((signed long)lowRPMHighLoad - lowRPMLowLoad) * (realLoad - lowLoadValue))/ (highLoadValue - lowLoadValue));
00180     unsigned short highRPMIntLoad = highRPMLowLoad + (((signed long)((signed long)highRPMHighLoad - highRPMLowLoad) * (realLoad - lowLoadValue))/ (highLoadValue - lowLoadValue));
00181 
00182     /* Interpolate between the two side values and return the result */
00183     return lowRPMIntLoad + (((signed long)((signed long)highRPMIntLoad - lowRPMIntLoad) * (realRPM - lowRPMValue))/ (highRPMValue - lowRPMValue));
00184 }
00185 
00186 
00198 unsigned short lookupTwoDTableUS(twoDTableUS * Table, unsigned short Value){
00199 
00200     /* Find the bounding axis indices, axis values and lookup values */
00201     unsigned char lowIndex = 0;
00202     unsigned char highIndex = 15;
00203     /* If never set in the loop, low value will equal high value and will be on the edge of the map */
00204     unsigned short lowAxisValue = Table->Axis[0];
00205     unsigned short highAxisValue = Table->Axis[15];
00206     unsigned short lowLookupValue = Table->Values[0];
00207     unsigned short highLookupValue = Table->Values[15];
00208 
00209     unsigned char Index;
00210     for(Index=0;Index<16;Index++){
00211         if(Table->Axis[Index] < Value){
00212             lowIndex = Index;
00213             lowAxisValue = Table->Axis[Index];
00214             lowLookupValue = Table->Values[Index];
00215         }else if(Table->Axis[Index] > Value){
00216             highIndex = Index;
00217             highAxisValue = Table->Axis[Index];
00218             highLookupValue = Table->Values[Index];
00219             break;
00220         }else if(Table->Axis[Index] == Value){
00221             return Table->Values[Index]; // If right on, just return the value
00222         }
00223     }
00224 
00225 
00226     /* Interpolate and return the value */
00227     return lowLookupValue + (((signed long)((signed long)highLookupValue - lowLookupValue) * (Value - lowAxisValue))/ (highAxisValue - lowAxisValue));
00228 }
00229 
00230 
00246 unsigned short setAxisValue(unsigned short index, unsigned short value, unsigned short axis[], unsigned short length, unsigned short errorBase){
00247     if(index >= length){
00248         return errorBase + invalidAxisIndex;
00249     }else{
00250         if(index > 0){
00251             /* Ensure value isn't lower than the one below */
00252             if(axis[index - 1] > value){
00253                 return errorBase + invalidAxisOrder;
00254             }
00255         }
00256         if(index < (length -1)){
00257             /* Ensure value isn't higher than the one above */
00258             if(value > axis[index + 1]){
00259                 return errorBase + invalidAxisOrder;
00260             }
00261         }
00262     }
00263 
00264     /* If we got this far all is well, set the value */
00265     axis[index] = value;
00266     return 0;
00267 }
00268 
00269 
00285 unsigned short setPagedMainTableCellValue(unsigned char RPageValue, mainTable* Table, unsigned short RPMIndex, unsigned short LoadIndex, unsigned short cellValue){
00286     unsigned char oldRPage = RPAGE;
00287     unsigned short errorID = 0;
00288     RPAGE = RPageValue;
00289     if(RPMIndex < Table->RPMLength){
00290         if(LoadIndex < Table->LoadLength){
00291             Table->Table[(Table->LoadLength * RPMIndex) + LoadIndex] = cellValue;
00292         }else{
00293             errorID = invalidMainTableLoadIndex;
00294         }
00295     }else{
00296         errorID = invalidMainTableRPMIndex;
00297     }
00298     RPAGE = oldRPage;
00299     return errorID;
00300 }
00301 
00302 
00317 unsigned short setPagedMainTableRPMValue(unsigned char RPageValue, mainTable* Table, unsigned short RPMIndex, unsigned short RPMValue){
00318     unsigned char oldRPage = RPAGE;
00319     RPAGE = RPageValue;
00320     unsigned short errorID = setAxisValue(RPMIndex, RPMValue, Table->RPM, Table->RPMLength, errorBaseMainTableRPM);
00321     RPAGE = oldRPage;
00322     return errorID;
00323 }
00324 
00325 
00340 unsigned short setPagedMainTableLoadValue(unsigned char RPageValue, mainTable* Table, unsigned short LoadIndex, unsigned short LoadValue){
00341     unsigned char oldRPage = RPAGE;
00342     RPAGE = RPageValue;
00343     unsigned short errorID = setAxisValue(LoadIndex, LoadValue, Table->Load, Table->LoadLength, errorBaseMainTableLoad);
00344     RPAGE = oldRPage;
00345     return errorID;
00346 }
00347 
00348 
00363 unsigned short setPagedTwoDTableCellValue(unsigned char RPageValue, twoDTableUS* Table, unsigned short cellIndex, unsigned short cellValue){
00364     if(cellIndex > 15){
00365         return invalidTwoDTableIndex;
00366     }else{
00367         unsigned char oldRPage = RPAGE;
00368         RPAGE = RPageValue;
00369         Table->Values[cellIndex] = cellValue;
00370         RPAGE = oldRPage;
00371         return 0;
00372     }
00373 }
00374 
00375 
00390 unsigned short setPagedTwoDTableAxisValue(unsigned char RPageValue, twoDTableUS* Table, unsigned short axisIndex, unsigned short axisValue){
00391     unsigned char oldRPage = RPAGE;
00392     RPAGE = RPageValue;
00393     unsigned short errorID = setAxisValue(axisIndex, axisValue, Table->Axis, 16, errorBaseTwoDTableAxis);
00394     RPAGE = oldRPage;
00395     return errorID;
00396 }
00397 
00398 
00410 unsigned short validateMainTable(mainTable* Table){
00411     /* If required and only if required extend this to take r and f pages and check */
00412     /* any main table, not just a freshly received untrusted ones in linear space   */
00413 
00414     if(Table->RPMLength > MAINTABLE_MAX_RPM_LENGTH){
00415         return invalidMainTableRPMLength;
00416     }else if(Table->LoadLength > MAINTABLE_MAX_LOAD_LENGTH){
00417         return invalidMainTableLoadLength;
00418     }else if((Table->RPMLength * Table->LoadLength) > MAINTABLE_MAX_MAIN_LENGTH){
00419         return invalidMainTableMainLength;
00420     }else{
00421         /* Check the order of the RPM axis */
00422         unsigned char i;
00423         for(i=0;i<(Table->RPMLength - 1);i++){
00424             if(Table->RPM[i] > Table->RPM[i+1]){
00425                 return invalidMainTableRPMOrder;
00426             }
00427         }
00428         /* Check the order of the Load axis */
00429         unsigned char j;
00430         for(j=0;j<(Table->LoadLength - 1);j++){
00431             if(Table->Load[j] > Table->Load[j+1]){
00432                 return invalidMainTableLoadOrder;
00433             }
00434         }
00435         /* If we made it this far all is well */
00436         return 0;
00437     }
00438 }
00439 
00440 
00452 unsigned short validateTwoDTable(twoDTableUS* Table){
00453     /* Check the order of the axis */
00454     unsigned char i;
00455     for(i=0;i<(TWODTABLEUS_LENGTH - 1);i++){
00456         if(Table->Axis[i] > Table->Axis[i+1]){
00457             return invalidTwoDTableAxisOrder;
00458         }
00459     }
00460     return 0;
00461 }