Subversion Repositories DashDisplay

Rev

Rev 28 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. #include "plx.h"
  2.  
  3. double ConveriMFDRaw2Data(int sensor, int units, int raw) {
  4.         double data = raw; // default assignment
  5.         switch (sensor) {
  6.         case PLX_AFR: //Wideband Air/Fuel
  7.                 switch (units) {
  8.                 case 0: //Lambda
  9.                         data = (raw / 3.75 + 68) / 100;
  10.                         break;
  11.                 case 1: //Gasoline 14.7
  12.                         data = (raw / 2.55 + 100) / 10;
  13.                         break;
  14.                 case 2: //Diesel 14.6
  15.                         data = (raw / 2.58 + 100) / 10;
  16.                         break;
  17.                 case 3: //Methanol 6.4
  18.                         data = (raw / 5.856 + 43.5) / 10;
  19.                         break;
  20.                 case 4: //Ethanol 9.0
  21.                         data = (raw / 4.167 + 61.7) / 10;
  22.                         break;
  23.                 case 5: //LPG 15.5
  24.                         data = (raw / 2.417 + 105.6) / 10;
  25.                         break;
  26.                 case 6: //CNG 17.2
  27.                         data = (raw / 2.18 + 117) / 10;
  28.                         break;
  29.                 }
  30.                 break;
  31.  
  32.             case PLX_X_CHT: // CHT extended
  33.             case PLX_AIT: //AIT
  34.                 case PLX_EGT: //EGT
  35.                 switch (units) {
  36.                 case 0: //Degrees Celsius
  37.                         data = raw;
  38.                         break;        
  39.                 case 1: //Degrees Fahrenheit
  40.                         data = (raw / .555 + 32);
  41.                         break;
  42.                 }
  43.                 break;
  44.  
  45.         case PLX_FluidTemp: //Fluid Temp
  46.                 switch (units) {
  47.                 case 0: //Degrees Celsius Water
  48.                 case 2: //Degrees Celsius Oil
  49.                         data = raw;
  50.                         break;
  51.                 case 1: //Degrees Fahrenheit Water
  52.                 case 3: //Degrees Fahrenheit Oil
  53.                         data = (raw / .555 + 32);
  54.                         break;
  55.                 }
  56.                 break;
  57.  
  58.         case PLX_Vac: //Vac
  59.                 switch (units) {
  60.                 case 0: //in/Hg (inch Mercury)
  61.                         data = -(raw / 11.39 - 29.93);
  62.                         break;
  63.                 case 1: //mm/Hg (millimeters Mercury)
  64.                         data = -(raw * 2.23 + 760.4);
  65.                         break;
  66.                 }
  67.                 break;
  68.  
  69.         case PLX_Boost: //Boost
  70.                 switch (units) {
  71.                 case 0: //0-30 PSI
  72.                         data = raw / 22.73;
  73.                         break;
  74.                 case 1: //0-2 kg/cm^2
  75.                         data = raw / 329.47;
  76.                         break;
  77.                 case 2: //0-15 PSI
  78.                         data = raw / 22.73;
  79.                         break;
  80.                 case 3: //0-1 kg/cm^2
  81.                         data = raw / 329.47;
  82.                         break;
  83.                 case 4: //0-60 PSI
  84.                         data = raw / 22.73;
  85.                         break;
  86.                 case 5: //0-4 kg/cm^2
  87.                         data = raw / 329.47;
  88.                         break;
  89.                 }
  90.                 break;
  91.  
  92.         case PLX_RPM: //RPM
  93.                 data = raw * 19.55; //RPM
  94.                 break;
  95.         case PLX_Speed: //Speed
  96.                 switch (units) {
  97.                 case 0: //MPH
  98.                         data = raw / 6.39;
  99.                         break;
  100.                 case 1: //KMH
  101.                         data = raw / 3.97;
  102.                         break;
  103.                 }
  104.                 break;
  105.         case PLX_TPS: //TPS
  106.                 data = raw; //Throttle Position %
  107.                 break;
  108.         case PLX_Load: //Engine Load
  109.                 data = raw; //Engine Load %
  110.                 break;
  111.         case PLX_FluidPressure: //Fluid Pressure
  112.                 switch (units) {
  113.                 case 0: //PSI Fuel
  114.                 case 3: //PSI Oil
  115.                         data = raw / 5.115;
  116.                         break;
  117.                 case 1: //kg/cm^2 Fuel
  118.                 case 4: //kg/cm^2 Oil
  119.                         data = raw / 72.73;
  120.                         break;
  121.                 case 2: //Bar Fuel
  122.                 case 5: //Bar Oil
  123.                         data = raw / 74.22;
  124.                         break;
  125.                 }
  126.                 break;
  127.         case PLX_Timing: //Engine timing
  128.                 data = raw - 64; //Degree Timing
  129.                 break;
  130.         case PLX_MAP: //MAP
  131.                 switch (units) {
  132.                 case 0: //kPa
  133.                         data = raw;
  134.                         break;
  135.                 case 1: //inHg
  136.                         data = raw / 3.386;
  137.                         break;
  138.                 }
  139.                 break;
  140.         case PLX_MAF: //MAF
  141.                 switch (units) {
  142.                 case 0: //g/s (grams per second)
  143.                         data = raw;
  144.                         break;
  145.                 case 1: //lb/min (pounds per minute)
  146.                         data = raw / 7.54;
  147.                         break;
  148.                 }
  149.                 break;
  150.         case PLX_ShortFuel: //Short term fuel trim
  151.                 data = raw - 100; //Fuel trim %
  152.                 break;
  153.         case PLX_LongFuel: //Long term fuel trim
  154.                 data = raw - 100; //Fuel trim %
  155.                 break;
  156.         case PLX_NBO2: //Narrowband O2 sensor
  157.                 switch (units) {
  158.                 case 0: //Percent
  159.                         data = raw;
  160.                         break;
  161.                 case 1: //Volts
  162.                         data = raw / 78.43;
  163.                         break;
  164.                 }
  165.                 break;
  166.         case PLX_Fuel: //Fuel level
  167.                 data = raw; //Fuel Level %
  168.                 break;
  169.         case PLX_Volts: //Volts
  170.                 data = raw / 51.15; //Volt Meter Volts
  171.                 break;
  172.         case PLX_Knock: //Knock
  173.                 data = raw / 204.6; //Knock volts 0-5
  174.                 break;
  175.         case PLX_Duty: //Duty cycle
  176.                 switch (units) {
  177.                 case 0: //Positive Duty
  178.                         data = raw / 10.23;
  179.                         break;
  180.                 case 1: //Negative Duty
  181.                         data = 100 - (raw / 10.23);
  182.                         break;
  183.                 }
  184.                 break;
  185.         }
  186.         return data;
  187. }
  188.  
  189.  
  190.  
  191.