tableLookup.c File Reference

#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 lookupPagedMainTableCellValue (mainTable *Table, unsigned short realRPM, unsigned short realLoad, unsigned char RPageValue)
unsigned short lookupTwoDTableUS (twoDTableUS *Table, unsigned short Value)
unsigned short setAxisValue (unsigned short index, unsigned short value, unsigned short axis[], unsigned short length, unsigned short errorBase)
unsigned short setPagedMainTableCellValue (unsigned char RPageValue, mainTable *Table, unsigned short RPMIndex, unsigned short LoadIndex, unsigned short cellValue)
unsigned short setPagedMainTableRPMValue (unsigned char RPageValue, mainTable *Table, unsigned short RPMIndex, unsigned short RPMValue)
unsigned short setPagedMainTableLoadValue (unsigned char RPageValue, mainTable *Table, unsigned short LoadIndex, unsigned short LoadValue)
unsigned short setPagedTwoDTableCellValue (unsigned char RPageValue, twoDTableUS *Table, unsigned short cellIndex, unsigned short cellValue)
unsigned short setPagedTwoDTableAxisValue (unsigned char RPageValue, twoDTableUS *Table, unsigned short axisIndex, unsigned short axisValue)
unsigned short validateMainTable (mainTable *Table)
unsigned short validateTwoDTable (twoDTableUS *Table)


Define Documentation

#define TABLELOOKUP_C

Definition at line 24 of file tableLookup.c.


Function Documentation

unsigned short lookupPagedMainTableCellValue ( mainTable Table,
unsigned short  realRPM,
unsigned short  realLoad,
unsigned char  RPageValue 
)

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 }

unsigned short lookupTwoDTableUS ( twoDTableUS Table,
unsigned short  Value 
)

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 }

unsigned short setAxisValue ( unsigned short  index,
unsigned short  value,
unsigned short  axis[],
unsigned short  length,
unsigned short  errorBase 
)

Definition at line 188 of file tableLookup.c.

References invalidAxisIndex, and invalidAxisOrder.

Referenced by setPagedMainTableLoadValue(), setPagedMainTableRPMValue(), and setPagedTwoDTableAxisValue().

00188                                                                                                                                                {
00189         if(index >= length){
00190                 return errorBase + invalidAxisIndex;
00191         }else{
00192                 if(index > 0){
00193                         /* Ensure value isn't lower than the one below */
00194                         if(axis[index - 1] > value){
00195                                 return errorBase + invalidAxisOrder;
00196                         }
00197                 }
00198                 if(index < (length -1)){
00199                         /* Ensure value isn't higher than the one above */
00200                         if(value > axis[index + 1]){
00201                                 return errorBase + invalidAxisOrder;
00202                         }
00203                 }
00204         }
00205 
00206         /* If we got this far all is well, set the value */
00207         axis[index] = value;
00208         return 0;
00209 }

unsigned short setPagedMainTableCellValue ( unsigned char  RPageValue,
mainTable Table,
unsigned short  RPMIndex,
unsigned short  LoadIndex,
unsigned short  cellValue 
)

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 }

unsigned short setPagedMainTableLoadValue ( unsigned char  RPageValue,
mainTable Table,
unsigned short  LoadIndex,
unsigned short  LoadValue 
)

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:

unsigned short setPagedMainTableRPMValue ( unsigned char  RPageValue,
mainTable Table,
unsigned short  RPMIndex,
unsigned short  RPMValue 
)

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:

unsigned short setPagedTwoDTableAxisValue ( unsigned char  RPageValue,
twoDTableUS Table,
unsigned short  axisIndex,
unsigned short  axisValue 
)

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:

unsigned short setPagedTwoDTableCellValue ( unsigned char  RPageValue,
twoDTableUS Table,
unsigned short  cellIndex,
unsigned short  cellValue 
)

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 }

unsigned short validateMainTable ( mainTable Table  ) 

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 }

unsigned short validateTwoDTable ( twoDTableUS Table  ) 

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 }


Generated on Mon Dec 22 21:30:28 2008 for freeems by  doxygen 1.5.2