Subversion Repositories DashDisplay

Rev

Rev 13 | Go to most recent revision | 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.         case PLX_EGT: //EGT
  32.                 switch (units) {
  33.                 case 0: //Degrees Celsius
  34.                         data = raw;
  35.                         break;
  36.                 case 1: //Degrees Fahrenheit
  37.                         data = (raw / .555 + 32);
  38.                         break;
  39.                 }
  40.                 break;
  41.  
  42.         case PLX_FluidTemp: //Fluid Temp
  43.                 switch (units) {
  44.                 case 0: //Degrees Celsius Water
  45.                 case 2: //Degrees Celsius Oil
  46.                         data = raw;
  47.                         break;
  48.                 case 1: //Degrees Fahrenheit Water
  49.                 case 3: //Degrees Fahrenheit Oil
  50.                         data = (raw / .555 + 32);
  51.                         break;
  52.                 }
  53.                 break;
  54.  
  55.         case PLX_Vac: //Vac
  56.                 switch (units) {
  57.                 case 0: //in/Hg (inch Mercury)
  58.                         data = -(raw / 11.39 - 29.93);
  59.                         break;
  60.                 case 1: //mm/Hg (millimeters Mercury)
  61.                         data = -(raw * 2.23 + 760.4);
  62.                         break;
  63.                 }
  64.                 break;
  65.  
  66.         case PLX_Boost: //Boost
  67.                 switch (units) {
  68.                 case 0: //0-30 PSI
  69.                         data = raw / 22.73;
  70.                         break;
  71.                 case 1: //0-2 kg/cm^2
  72.                         data = raw / 329.47;
  73.                         break;
  74.                 case 2: //0-15 PSI
  75.                         data = raw / 22.73;
  76.                         break;
  77.                 case 3: //0-1 kg/cm^2
  78.                         data = raw / 329.47;
  79.                         break;
  80.                 case 4: //0-60 PSI
  81.                         data = raw / 22.73;
  82.                         break;
  83.                 case 5: //0-4 kg/cm^2
  84.                         data = raw / 329.47;
  85.                         break;
  86.                 }
  87.                 break;
  88.  
  89.         case PLX_AIT: //AIT
  90.                 switch (units) {
  91.                 case 0: //Celsius
  92.                         data = raw;
  93.                         break;
  94.                 case 1: //Fahrenheit
  95.                         data = (raw / .555 + 32);
  96.                         break;
  97.                 }
  98.                 break;
  99.         case PLX_RPM: //RPM
  100.                 data = raw * 19.55; //RPM
  101.                 break;
  102.         case PLX_Speed: //Speed
  103.                 switch (units) {
  104.                 case 0: //MPH
  105.                         data = raw / 6.39;
  106.                         break;
  107.                 case 1: //KMH
  108.                         data = raw / 3.97;
  109.                         break;
  110.                 }
  111.                 break;
  112.         case PLX_TPS: //TPS
  113.                 data = raw; //Throttle Position %
  114.                 break;
  115.         case PLX_Load: //Engine Load
  116.                 data = raw; //Engine Load %
  117.                 break;
  118.         case PLX_FluidPressure: //Fluid Pressure
  119.                 switch (units) {
  120.                 case 0: //PSI Fuel
  121.                 case 3: //PSI Oil
  122.                         data = raw / 5.115;
  123.                         break;
  124.                 case 1: //kg/cm^2 Fuel
  125.                 case 4: //kg/cm^2 Oil
  126.                         data = raw / 72.73;
  127.                         break;
  128.                 case 2: //Bar Fuel
  129.                 case 5: //Bar Oil
  130.                         data = raw / 74.22;
  131.                         break;
  132.                 }
  133.                 break;
  134.         case PLX_Timing: //Engine timing
  135.                 data = raw - 64; //Degree Timing
  136.                 break;
  137.         case PLX_MAP: //MAP
  138.                 switch (units) {
  139.                 case 0: //kPa
  140.                         data = raw;
  141.                         break;
  142.                 case 1: //inHg
  143.                         data = raw / 3.386;
  144.                         break;
  145.                 }
  146.                 break;
  147.         case PLX_MAF: //MAF
  148.                 switch (units) {
  149.                 case 0: //g/s (grams per second)
  150.                         data = raw;
  151.                         break;
  152.                 case 1: //lb/min (pounds per minute)
  153.                         data = raw / 7.54;
  154.                         break;
  155.                 }
  156.                 break;
  157.         case PLX_ShortFuel: //Short term fuel trim
  158.                 data = raw - 100; //Fuel trim %
  159.                 break;
  160.         case PLX_LongFuel: //Long term fuel trim
  161.                 data = raw - 100; //Fuel trim %
  162.                 break;
  163.         case PLX_NBO2: //Narrowband O2 sensor
  164.                 switch (units) {
  165.                 case 0: //Percent
  166.                         data = raw;
  167.                         break;
  168.                 case 1: //Volts
  169.                         data = raw / 78.43;
  170.                         break;
  171.                 }
  172.                 break;
  173.         case PLX_Fuel: //Fuel level
  174.                 data = raw; //Fuel Level %
  175.                 break;
  176.         case PLX_Volts: //Volts
  177.                 data = raw / 51.15; //Volt Meter Volts
  178.                 break;
  179.         case PLX_Knock: //Knock
  180.                 data = raw / 204.6; //Knock volts 0-5
  181.                 break;
  182.         case PLX_Duty: //Duty cycle
  183.                 switch (units) {
  184.                 case 0: //Positive Duty
  185.                         data = raw / 10.23;
  186.                         break;
  187.                 case 1: //Negative Duty
  188.                         data = 100 - (raw / 10.23);
  189.                         break;
  190.                 }
  191.                 break;
  192.         }
  193.         return data;
  194. }
  195.  
  196.