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 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 Documentation

#define TABLELOOKUP_C

Definition at line 24 of file tableLookup.c.


Function Documentation

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 }


Generated on Mon Nov 10 21:19:16 2008 for freeems by  doxygen 1.5.2