This graph shows which files directly or indirectly include this file:
Go to the source code of this file.
Defines | |
#define | EXTERN extern |
Functions | |
EXTERN unsigned short | lookupTwoDTableUS (twoDTableUS *, unsigned short) TEXT |
EXTERN unsigned short | lookupPagedMainTableCellValue (mainTable *, unsigned short, unsigned short, unsigned char) TEXT |
EXTERN unsigned short | setPagedMainTableCellValue (unsigned char, mainTable *, unsigned short, unsigned short, unsigned short) TEXT |
EXTERN unsigned short | setPagedMainTableRPMValue (unsigned char, mainTable *, unsigned short, unsigned short) TEXT |
EXTERN unsigned short | setPagedMainTableLoadValue (unsigned char, mainTable *, unsigned short, unsigned short) TEXT |
EXTERN unsigned short | setPagedTwoDTableCellValue (unsigned char, twoDTableUS *, unsigned short, unsigned short) TEXT |
EXTERN unsigned short | setPagedTwoDTableAxisValue (unsigned char, twoDTableUS *, unsigned short, unsigned short) TEXT |
EXTERN unsigned short | validateMainTable (mainTable *) TEXT |
EXTERN unsigned short | validateTwoDTable (twoDTableUS *) TEXT |
#define EXTERN extern |
Definition at line 32 of file tableLookup.h.
EXTERN unsigned short lookupPagedMainTableCellValue | ( | mainTable * | , | |
unsigned | short, | |||
unsigned | short, | |||
unsigned | char | |||
) |
Definition at line 75 of file tableLookup.c.
References RPAGE, mainTable::RPM, and mainTable::RPMLength.
Referenced by generateDerivedVars().
00075 { 00076 00077 /* Save the RPAGE value for restoration and switch pages. */ 00078 unsigned char oldRPage = RPAGE; 00079 RPAGE = RPageValue; 00080 00081 /* Find the bounding axis values and indices for RPM */ 00082 unsigned char lowRPMIndex = 0; 00083 unsigned char highRPMIndex = Table->RPMLength - 1; 00084 /* If never set in the loop, low value will equal high value and will be on the edge of the map */ 00085 unsigned short lowRPMValue = Table->RPM[0]; 00086 unsigned short highRPMValue = Table->RPM[Table->RPMLength -1]; 00087 00088 unsigned char RPMIndex; 00089 for(RPMIndex=0;RPMIndex<Table->RPMLength;RPMIndex++){ 00090 if(Table->RPM[RPMIndex] < realRPM){ 00091 lowRPMValue = Table->RPM[RPMIndex]; 00092 lowRPMIndex = RPMIndex; 00093 }else if(Table->RPM[RPMIndex] > realRPM){ 00094 highRPMValue = Table->RPM[RPMIndex]; 00095 highRPMIndex = RPMIndex; 00096 break; 00097 }else if(Table->RPM[RPMIndex] == realRPM){ 00098 lowRPMValue = Table->RPM[RPMIndex]; 00099 highRPMValue = Table->RPM[RPMIndex]; 00100 lowRPMIndex = RPMIndex; 00101 highRPMIndex = RPMIndex; 00102 break; 00103 } 00104 } 00105 00106 00107 /* Find the bounding cell values and indices for Load */ 00108 unsigned char lowLoadIndex = 0; 00109 unsigned char highLoadIndex = Table->LoadLength -1; 00110 /* If never set in the loop, low value will equal high value and will be on the edge of the map */ 00111 unsigned short lowLoadValue = Table->Load[0]; 00112 unsigned short highLoadValue = Table->Load[Table->LoadLength -1]; 00113 00114 unsigned char LoadIndex; 00115 for(LoadIndex=0;LoadIndex<Table->LoadLength;LoadIndex++){ 00116 if(Table->Load[LoadIndex] < realLoad){ 00117 lowLoadValue = Table->Load[LoadIndex]; 00118 lowLoadIndex = LoadIndex; 00119 }else if(Table->Load[LoadIndex] > realLoad){ 00120 highLoadValue = Table->Load[LoadIndex]; 00121 highLoadIndex = LoadIndex; 00122 break; 00123 }else if(Table->Load[LoadIndex] == realLoad){ 00124 lowLoadValue = Table->Load[LoadIndex]; 00125 highLoadValue = Table->Load[LoadIndex]; 00126 lowLoadIndex = LoadIndex; 00127 highLoadIndex = LoadIndex; 00128 break; 00129 } 00130 } 00131 00132 00133 /* Obtain the four corners surrounding the spot of interest */ 00134 unsigned short lowRPMLowLoad = Table->Table[(Table->LoadLength * lowRPMIndex) + lowLoadIndex]; 00135 unsigned short lowRPMHighLoad = Table->Table[(Table->LoadLength * lowRPMIndex) + highLoadIndex]; 00136 unsigned short highRPMLowLoad = Table->Table[(Table->LoadLength * highRPMIndex) + lowLoadIndex]; 00137 unsigned short highRPMHighLoad = Table->Table[(Table->LoadLength * highRPMIndex) + highLoadIndex]; 00138 00139 00140 /* Restore the ram page before doing the math */ 00141 RPAGE = oldRPage; 00142 00143 00144 /* Find the two side values to interpolate between by interpolation */ 00145 unsigned short lowRPMIntLoad = lowRPMLowLoad + (((signed long)((signed long)lowRPMHighLoad - lowRPMLowLoad) * (realLoad - lowLoadValue))/ (highLoadValue - lowLoadValue)); 00146 unsigned short highRPMIntLoad = highRPMLowLoad + (((signed long)((signed long)highRPMHighLoad - highRPMLowLoad) * (realLoad - lowLoadValue))/ (highLoadValue - lowLoadValue)); 00147 00148 00149 /* Interpolate between the two side values and return the result */ 00150 return lowRPMIntLoad + (((signed long)((signed long)highRPMIntLoad - lowRPMIntLoad) * (realRPM - lowRPMValue))/ (highRPMValue - lowRPMValue)); 00151 }
EXTERN unsigned short lookupTwoDTableUS | ( | twoDTableUS * | , | |
unsigned | short | |||
) |
Definition at line 154 of file tableLookup.c.
References twoDTableUS::Axis, and twoDTableUS::Values.
Referenced by generateDerivedVars().
00154 { 00155 00156 /* Find the bounding axis indices, axis values and lookup values */ 00157 unsigned char lowIndex = 0; 00158 unsigned char highIndex = 15; 00159 /* If never set in the loop, low value will equal high value and will be on the edge of the map */ 00160 unsigned short lowAxisValue = Table->Axis[0]; 00161 unsigned short highAxisValue = Table->Axis[15]; 00162 unsigned short lowLookupValue = Table->Values[0]; 00163 unsigned short highLookupValue = Table->Values[15]; 00164 00165 unsigned char Index; 00166 for(Index=0;Index<16;Index++){ 00167 if(Table->Axis[Index] < Value){ 00168 lowIndex = Index; 00169 lowAxisValue = Table->Axis[Index]; 00170 lowLookupValue = Table->Values[Index]; 00171 }else if(Table->Axis[Index] > Value){ 00172 highIndex = Index; 00173 highAxisValue = Table->Axis[Index]; 00174 highLookupValue = Table->Values[Index]; 00175 break; 00176 }else if(Table->Axis[Index] == Value){ 00177 return Table->Values[Index]; // If right on, just return the value 00178 } 00179 } 00180 00181 00182 /* Interpolate and return the value */ 00183 return lowLookupValue + (((signed long)((signed long)highLookupValue - lowLookupValue) * (Value - lowAxisValue))/ (highAxisValue - lowAxisValue)); 00184 }
EXTERN unsigned short setPagedMainTableCellValue | ( | unsigned | char, | |
mainTable * | , | |||
unsigned | short, | |||
unsigned | short, | |||
unsigned | short | |||
) |
Definition at line 212 of file tableLookup.c.
References invalidMainTableLoadIndex, invalidMainTableRPMIndex, mainTable::LoadLength, RPAGE, and mainTable::Table.
Referenced by decodePacketAndRespond().
00212 { 00213 unsigned char oldRPage = RPAGE; 00214 unsigned short errorID = 0; 00215 RPAGE = RPageValue; 00216 if(RPMIndex < Table->RPMLength){ 00217 if(LoadIndex < Table->LoadLength){ 00218 Table->Table[(Table->LoadLength * RPMIndex) + LoadIndex] = cellValue; 00219 }else{ 00220 errorID = invalidMainTableLoadIndex; 00221 } 00222 }else{ 00223 errorID = invalidMainTableRPMIndex; 00224 } 00225 RPAGE = oldRPage; 00226 return errorID; 00227 }
EXTERN unsigned short setPagedMainTableLoadValue | ( | unsigned | char, | |
mainTable * | , | |||
unsigned | short, | |||
unsigned | short | |||
) |
Definition at line 239 of file tableLookup.c.
References errorBaseMainTableLoad, mainTable::Load, mainTable::LoadLength, RPAGE, and setAxisValue().
Referenced by decodePacketAndRespond().
00239 { 00240 unsigned char oldRPage = RPAGE; 00241 RPAGE = RPageValue; 00242 unsigned short errorID = setAxisValue(LoadIndex, LoadValue, Table->Load, Table->LoadLength, errorBaseMainTableLoad); 00243 RPAGE = oldRPage; 00244 return errorID; 00245 }
Here is the call graph for this function:
EXTERN unsigned short setPagedMainTableRPMValue | ( | unsigned | char, | |
mainTable * | , | |||
unsigned | short, | |||
unsigned | short | |||
) |
Definition at line 230 of file tableLookup.c.
References errorBaseMainTableRPM, RPAGE, mainTable::RPM, mainTable::RPMLength, and setAxisValue().
Referenced by decodePacketAndRespond().
00230 { 00231 unsigned char oldRPage = RPAGE; 00232 RPAGE = RPageValue; 00233 unsigned short errorID = setAxisValue(RPMIndex, RPMValue, Table->RPM, Table->RPMLength, errorBaseMainTableRPM); 00234 RPAGE = oldRPage; 00235 return errorID; 00236 }
Here is the call graph for this function:
EXTERN unsigned short setPagedTwoDTableAxisValue | ( | unsigned | char, | |
twoDTableUS * | , | |||
unsigned | short, | |||
unsigned | short | |||
) |
Definition at line 261 of file tableLookup.c.
References twoDTableUS::Axis, errorBaseTwoDTableAxis, RPAGE, and setAxisValue().
Referenced by decodePacketAndRespond().
00261 { 00262 unsigned char oldRPage = RPAGE; 00263 RPAGE = RPageValue; 00264 unsigned short errorID = setAxisValue(axisIndex, axisValue, Table->Axis, 16, errorBaseTwoDTableAxis); 00265 RPAGE = oldRPage; 00266 return errorID; 00267 }
Here is the call graph for this function:
EXTERN unsigned short setPagedTwoDTableCellValue | ( | unsigned | char, | |
twoDTableUS * | , | |||
unsigned | short, | |||
unsigned | short | |||
) |
Definition at line 248 of file tableLookup.c.
References invalidTwoDTableIndex, RPAGE, and twoDTableUS::Values.
Referenced by decodePacketAndRespond().
00248 { 00249 if(cellIndex > 15){ 00250 return invalidTwoDTableIndex; 00251 }else{ 00252 unsigned char oldRPage = RPAGE; 00253 RPAGE = RPageValue; 00254 Table->Values[cellIndex] = cellValue; 00255 RPAGE = oldRPage; 00256 return 0; 00257 } 00258 }
EXTERN unsigned short validateMainTable | ( | mainTable * | ) |
Definition at line 271 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 decodePacketAndRespond().
00271 { 00272 /* If required and only if required extend this to take r and f pages and check */ 00273 /* any main table, not just a freshly received untrusted ones in linear space */ 00274 00275 if(Table->RPMLength > MAINTABLE_MAX_RPM_LENGTH){ 00276 return invalidMainTableRPMLength; 00277 }else if(Table->LoadLength > MAINTABLE_MAX_LOAD_LENGTH){ 00278 return invalidMainTableLoadLength; 00279 }else if((Table->RPMLength * Table->LoadLength) > MAINTABLE_MAX_MAIN_LENGTH){ 00280 return invalidMainTableMainLength; 00281 }else{ 00282 /* Check the order of the RPM axis */ 00283 unsigned char i; 00284 for(i=0;i<(Table->RPMLength - 1);i++){ 00285 if(Table->RPM[i] > Table->RPM[i+1]){ 00286 return invalidMainTableRPMOrder; 00287 } 00288 } 00289 /* Check the order of the Load axis */ 00290 unsigned char j; 00291 for(j=0;j<(Table->LoadLength - 1);j++){ 00292 if(Table->Load[j] > Table->Load[j+1]){ 00293 return invalidMainTableLoadOrder; 00294 } 00295 } 00296 /* If we made it this far all is well */ 00297 return 0; 00298 } 00299 }
EXTERN unsigned short validateTwoDTable | ( | twoDTableUS * | ) |
Definition at line 303 of file tableLookup.c.
References twoDTableUS::Axis, invalidTwoDTableAxisOrder, and TWODTABLEUS_LENGTH.
Referenced by decodePacketAndRespond().
00303 { 00304 /* Check the order of the axis */ 00305 unsigned char i; 00306 for(i=0;i<(TWODTABLEUS_LENGTH - 1);i++){ 00307 if(Table->Axis[i] > Table->Axis[i+1]){ 00308 return invalidTwoDTableAxisOrder; 00309 } 00310 } 00311 return 0; 00312 }