#include "inc/freeEMS.h"
#include "inc/commsISRs.h"
#include "inc/tableLookup.h"
Include dependency graph for tableLookup.c:
Go to the source code of this file.
Defines | |
#define | TABLELOOKUP_C |
Functions | |
unsigned short | lookupMainTable (mainTable *Table, unsigned short realRPM, unsigned short realLoad) |
unsigned short | lookupTwoDTableUS (twoDTableUS *Table, unsigned short Value) |
unsigned short | lookupPagedMainTableCellValue (mainTable *Table, unsigned short realRPM, unsigned short realLoad, unsigned char RPageValue) |
unsigned short | setPagedMainTableCellValue (mainTable *Table, unsigned short RPMIndex, unsigned short LoadIndex, unsigned short cellValue, unsigned char RPageValue) |
unsigned short | setPagedMainTableRPMValue (mainTable *Table, unsigned short RPMIndex, unsigned short RPMValue, unsigned char RPageValue) |
unsigned short | setPagedMainTableLoadValue (mainTable *Table, unsigned short LoadIndex, unsigned short LoadValue, unsigned char RPageValue) |
unsigned short | validateMainTable (mainTable *Table) |
unsigned short | validateTwoDTable (twoDTableUS *Table) |
#define TABLELOOKUP_C |
Definition at line 24 of file tableLookup.c.
unsigned short lookupMainTable | ( | mainTable * | Table, | |
unsigned short | realRPM, | |||
unsigned short | realLoad | |||
) |
Definition at line 52 of file tableLookup.c.
References mainTable::RPM, and mainTable::RPMLength.
Referenced by lookupPagedMainTableCellValue().
00052 { 00053 00054 /* Find the bounding axis values and indices for RPM */ 00055 unsigned char lowRPMIndex = 0; 00056 unsigned char highRPMIndex = Table->RPMLength - 1; 00057 /* If never set in the loop, low value will equal high value and will be on the edge of the map */ 00058 unsigned short lowRPMValue = Table->RPM[0]; 00059 unsigned short highRPMValue = Table->RPM[Table->RPMLength -1]; 00060 00061 unsigned char RPMIndex; 00062 for(RPMIndex=0;RPMIndex<Table->RPMLength;RPMIndex++){ 00063 if(Table->RPM[RPMIndex] < realRPM){ 00064 lowRPMValue = Table->RPM[RPMIndex]; 00065 lowRPMIndex = RPMIndex; 00066 }else if(Table->RPM[RPMIndex] > realRPM){ 00067 highRPMValue = Table->RPM[RPMIndex]; 00068 highRPMIndex = RPMIndex; 00069 break; 00070 }else if(Table->RPM[RPMIndex] == realRPM){ 00071 lowRPMValue = Table->RPM[RPMIndex]; 00072 highRPMValue = Table->RPM[RPMIndex]; 00073 lowRPMIndex = RPMIndex; 00074 highRPMIndex = RPMIndex; 00075 break; 00076 } 00077 } 00078 00079 00080 /* Find the bounding cell values and indices for Load */ 00081 unsigned char lowLoadIndex = 0; 00082 unsigned char highLoadIndex = Table->LoadLength -1; 00083 /* If never set in the loop, low value will equal high value and will be on the edge of the map */ 00084 unsigned short lowLoadValue = Table->Load[0]; 00085 unsigned short highLoadValue = Table->Load[Table->LoadLength -1]; 00086 00087 unsigned char LoadIndex; 00088 for(LoadIndex=0;LoadIndex<Table->LoadLength;LoadIndex++){ 00089 if(Table->Load[LoadIndex] < realLoad){ 00090 lowLoadValue = Table->Load[LoadIndex]; 00091 lowLoadIndex = LoadIndex; 00092 }else if(Table->Load[LoadIndex] > realLoad){ 00093 highLoadValue = Table->Load[LoadIndex]; 00094 highLoadIndex = LoadIndex; 00095 break; 00096 }else if(Table->Load[LoadIndex] == realLoad){ 00097 lowLoadValue = Table->Load[LoadIndex]; 00098 highLoadValue = Table->Load[LoadIndex]; 00099 lowLoadIndex = LoadIndex; 00100 highLoadIndex = LoadIndex; 00101 break; 00102 } 00103 } 00104 00105 00106 /* Obtain the four corners surrounding the spot of interest */ 00107 unsigned short lowRPMLowLoad = Table->Table[(Table->LoadLength * lowRPMIndex) + lowLoadIndex]; 00108 unsigned short lowRPMHighLoad = Table->Table[(Table->LoadLength * lowRPMIndex) + highLoadIndex]; 00109 unsigned short highRPMLowLoad = Table->Table[(Table->LoadLength * highRPMIndex) + lowLoadIndex]; 00110 unsigned short highRPMHighLoad = Table->Table[(Table->LoadLength * highRPMIndex) + highLoadIndex]; 00111 00112 00113 /* Find the two side values to interpolate between by interpolation */ 00114 unsigned short lowRPMIntLoad = lowRPMLowLoad + (((signed long)((signed long)lowRPMHighLoad - lowRPMLowLoad) * (realLoad - lowLoadValue))/ (highLoadValue - lowLoadValue)); 00115 unsigned short highRPMIntLoad = highRPMLowLoad + (((signed long)((signed long)highRPMHighLoad - highRPMLowLoad) * (realLoad - lowLoadValue))/ (highLoadValue - lowLoadValue)); 00116 00117 00118 /* Interpolate between the two side values and return the result */ 00119 return lowRPMIntLoad + (((signed long)((signed long)highRPMIntLoad - lowRPMIntLoad) * (realRPM - lowRPMValue))/ (highRPMValue - lowRPMValue)); 00120 }
unsigned short lookupPagedMainTableCellValue | ( | mainTable * | Table, | |
unsigned short | realRPM, | |||
unsigned short | realLoad, | |||
unsigned char | RPageValue | |||
) |
Definition at line 157 of file tableLookup.c.
References lookupMainTable(), and RPAGE.
Referenced by generateDerivedVars().
00157 { 00158 unsigned char oldRPage = RPAGE; 00159 RPAGE = RPageValue; 00160 unsigned short returnValue = lookupMainTable(Table, realRPM, realLoad); 00161 RPAGE = oldRPage; 00162 return returnValue; 00163 }
Here is the call graph for this function:
unsigned short lookupTwoDTableUS | ( | twoDTableUS * | Table, | |
unsigned short | Value | |||
) |
Definition at line 123 of file tableLookup.c.
References twoDTableUS::Axis, and twoDTableUS::Values.
Referenced by generateDerivedVars().
00123 { 00124 00125 /* Find the bounding axis indices, axis values and lookup values */ 00126 unsigned char lowIndex = 0; 00127 unsigned char highIndex = 15; 00128 /* If never set in the loop, low value will equal high value and will be on the edge of the map */ 00129 unsigned short lowAxisValue = Table->Axis[0]; 00130 unsigned short highAxisValue = Table->Axis[15]; 00131 unsigned short lowLookupValue = Table->Values[0]; 00132 unsigned short highLookupValue = Table->Values[15]; 00133 00134 unsigned char Index; 00135 for(Index=0;Index<16;Index++){ 00136 if(Table->Axis[Index] < Value){ 00137 lowIndex = Index; 00138 lowAxisValue = Table->Axis[Index]; 00139 lowLookupValue = Table->Values[Index]; 00140 }else if(Table->Axis[Index] > Value){ 00141 highIndex = Index; 00142 highAxisValue = Table->Axis[Index]; 00143 highLookupValue = Table->Values[Index]; 00144 break; 00145 }else if(Table->Axis[Index] == Value){ 00146 return Table->Values[Index]; // If right on, just return the value 00147 } 00148 } 00149 00150 00151 /* Interpolate and return the value */ 00152 return lowLookupValue + (((signed long)((signed long)highLookupValue - lowLookupValue) * (Value - lowAxisValue))/ (highAxisValue - lowAxisValue)); 00153 }
unsigned short setPagedMainTableCellValue | ( | mainTable * | Table, | |
unsigned short | RPMIndex, | |||
unsigned short | LoadIndex, | |||
unsigned short | cellValue, | |||
unsigned char | RPageValue | |||
) |
Definition at line 166 of file tableLookup.c.
References invalidMainTableLoadIndex, invalidMainTableRPMIndex, mainTable::LoadLength, NO_ERROR_ALL_A_OK, RPAGE, and mainTable::Table.
Referenced by decodePacketAndBuildResponse().
00166 { 00167 unsigned char oldRPage = RPAGE; 00168 unsigned short errorID = NO_ERROR_ALL_A_OK; 00169 RPAGE = RPageValue; 00170 if(RPMIndex < Table->RPMLength){ 00171 if(LoadIndex < Table->LoadLength){ 00172 Table->Table[(Table->LoadLength * RPMIndex) + LoadIndex] = cellValue; 00173 }else{ 00174 errorID = invalidMainTableLoadIndex; 00175 } 00176 }else{ 00177 errorID = invalidMainTableRPMIndex; 00178 } 00179 RPAGE = oldRPage; 00180 return errorID; 00181 }
unsigned short setPagedMainTableLoadValue | ( | mainTable * | Table, | |
unsigned short | LoadIndex, | |||
unsigned short | LoadValue, | |||
unsigned char | RPageValue | |||
) |
Definition at line 198 of file tableLookup.c.
References invalidMainTableLoadIndex, mainTable::Load, NO_ERROR_ALL_A_OK, and RPAGE.
Referenced by decodePacketAndBuildResponse().
00198 { 00199 unsigned char oldRPage = RPAGE; 00200 unsigned short errorID = NO_ERROR_ALL_A_OK; 00201 RPAGE = RPageValue; 00202 if(LoadIndex < Table->LoadLength){ 00203 Table->Load[LoadIndex] = LoadValue; 00204 }else{ 00205 errorID = invalidMainTableLoadIndex; 00206 } 00207 RPAGE = oldRPage; 00208 return errorID; 00209 }
unsigned short setPagedMainTableRPMValue | ( | mainTable * | Table, | |
unsigned short | RPMIndex, | |||
unsigned short | RPMValue, | |||
unsigned char | RPageValue | |||
) |
Definition at line 184 of file tableLookup.c.
References invalidMainTableRPMIndex, NO_ERROR_ALL_A_OK, RPAGE, and mainTable::RPM.
Referenced by decodePacketAndBuildResponse().
00184 { 00185 unsigned char oldRPage = RPAGE; 00186 unsigned short errorID = NO_ERROR_ALL_A_OK; 00187 RPAGE = RPageValue; 00188 if(RPMIndex < Table->RPMLength){ 00189 Table->RPM[RPMIndex] = RPMValue; 00190 }else{ 00191 errorID = invalidMainTableRPMIndex; 00192 } 00193 RPAGE = oldRPage; 00194 return errorID; 00195 }
unsigned short validateMainTable | ( | mainTable * | Table | ) |
Definition at line 213 of file tableLookup.c.
References invalidMainTableLoadLength, invalidMainTableLoadOrder, invalidMainTableMainLength, invalidMainTableRPMLength, invalidMainTableRPMOrder, mainTable::Load, mainTable::LoadLength, MAINTABLE_MAX_LOAD_LENGTH, MAINTABLE_MAX_MAIN_LENGTH, MAINTABLE_MAX_RPM_LENGTH, mainTable::RPM, and mainTable::RPMLength.
Referenced by decodePacketAndBuildResponse().
00213 { 00214 if(Table->RPMLength > MAINTABLE_MAX_RPM_LENGTH){ 00215 return invalidMainTableRPMLength; 00216 }else if(Table->LoadLength > MAINTABLE_MAX_LOAD_LENGTH){ 00217 return invalidMainTableLoadLength; 00218 }else if((Table->RPMLength * Table->LoadLength) > MAINTABLE_MAX_MAIN_LENGTH){ 00219 return invalidMainTableMainLength; 00220 }else{ 00221 /* Check the order of the RPM axis */ 00222 unsigned char i; 00223 for(i=0;i<(Table->RPMLength - 1);i++){ 00224 if(Table->RPM[i] > Table->RPM[i+1]){ 00225 return invalidMainTableRPMOrder; 00226 } 00227 } 00228 /* Check the order of the Load axis */ 00229 unsigned char j; 00230 for(j=0;j<(Table->LoadLength - 1);j++){ 00231 if(Table->Load[j] > Table->Load[j+1]){ 00232 return invalidMainTableLoadOrder; 00233 } 00234 } 00235 /* If we made it this far all is well */ 00236 return NO_ERROR_ALL_A_OK; 00237 } 00238 }
unsigned short validateTwoDTable | ( | twoDTableUS * | Table | ) |
Definition at line 241 of file tableLookup.c.
References twoDTableUS::Axis, invalidTwoDTableAxisOrder, and TWODTABLEUS_LENGTH.
Referenced by decodePacketAndBuildResponse().
00241 { 00242 /* Check the order of the axis */ 00243 unsigned char i; 00244 for(i=0;i<(TWODTABLEUS_LENGTH - 1);i++){ 00245 if(Table->Axis[i] > Table->Axis[i+1]){ 00246 return invalidTwoDTableAxisOrder; 00247 } 00248 } 00249 return NO_ERROR_ALL_A_OK; 00250 }