...

; var can_data = [ ["ECT","Engine Coolant Temp","576","1","8","","x|40|-","A-40","°C",""], ["RPM","Engine RPM","513","0","16","","x|0.25|*","((A*256)+B)*0.25","rpm",""], ["VSS","Vehicle Speed Sensor","513","4","16","","x","((A*256)+B)","km/h",""], ["TP","TP","513","6","8","","x","A","%",""], ["ABSFlag","","533","7","8","4","x","A","",""], ["LOAD_CALC","Load Calculated","576","0","8","","x|0.3921568627|*","A*0.3921568627","%",""], ["SPARKADV","Ignition Timing Advance","576","2","8","","x|128|-|0.5|*","(A-128)*0.5","(angle)°",""] ] ; var obd_data = [ ["PIDS_01_T0_20","Supported PIDs 01 - 32","0x01","0x00","32","","","","","Bit encoded"], ["MS_DTC_CLEARED","Monitor Status: DTCs Cleared","0x01","0x01","32","","","","","Bit encoded"], ["FUELSYS","Fuel System Status","0x01","0x03","16","","","","","Bit encoded"], ["LOAD_CALC","Load Calculated","0x01","0x04","8","","x|0.3921568627|*","A*0.3921568627","%",""], ["ECT","Engine Coolant Temp","0x01","0x05","8","","x|40|-","A-40","°C",""], ["STFT","Short Term Fuel Trim","0x01","0x06","8","","x|128|-|0.78125|*","(A-128)*0.78125","%",""], ["LTFT","Long Term Fuel Trim","0x01","0x07","8","","x|128|-|0.78125|*","(A-128)*0.78125","%",""], ["MAP","Manifold Absolute Pressure","0x01","0x0B","8","","x","A","kPa",""], ["RPM","Engine RPM","0x01","0x0C","16","","x|0.25|*","((A*256)+B)*0.25","rpm",""], ["VSS","Vehicle Speed Sensor","0x01","0x0D","8","","x","A","km/h",""], ["SPARKADV","Ignition Timing Advance","0x01","0x0E","8","","x|128|-|0.5|*","(A-128)*0.5","(angle)°",""], ["IAT","Intake Air Temperature","0x01","0x0F","8","","x|0.25|*","A*0.25","°C",""], ["MAF","Mass Air-Flow","0x01","0x10","16","","x|0.01|*","((A*256)+B)*0.01","g/sec",""], ["TP1","Throttle Position 1 Absolute","0x01","0x11","8","","x|0.3921568627|*","A*0.3921568627","%",""], ["O2S_PRESENT","# of O2 Sensors Present","0x01","0x13","8","","","","","Bit encoded"], ["O2S12_V","Rear O2 Sensor Voltage","0x01","0x15","16","","x|0.00390625|*|0.005|*","A*0.005","V","B is set to 0xFF internally (ignore)"], ["OBD_STANDARDS","List Complied Standards","0x01","0x1C","8","","","","","Bit encoded"], ["RUNTIME","Runtime since engine start","0x01","0x1F","16","","x","(A*256)+B","secs",""], ["PIDS_21_to_40","Supported PIDs 33 - 64","0x01","0x20","32","","","","","Bit encoded"], ["MIL_DIST","Distance w/ MIL on","0x01","0x21","16","","x","(A*256)+B","km",""], ["EGRP_DSD","EGR Purge Desired","0x01","0x2C","8","","x|0.3921568627|*","A*0.3921568627","%",""], ["EVAPCP","EVAP Canister Purge","0x01","0x2E","8","","x|0.3921568627|*","A*0.3921568627","%",""], ["FLI","Fuel Level Indicator","0x01","0x2F","8","","x|0.3921568627|*","A*0.3921568627","%",""], ["DTC_CLR_WARMUPS","warmups since DTCs cleared","0x01","0x30","8","","x","A","",""], ["DTC_CLR_DIST","Distance w/ DTCs Cleared","0x01","0x31","16","","x","(A*256)+B","km",""], ["BARO","Barometric Pressure","0x01","0x33","8","","x","A","kPa",""], ["EQ_RATIO_ACT","AFR(λ) Actual","0x01","0x34","32","","x|0.00001525878906|*|0.00003051757812|*","((A*256)+B)*0.00003051757812","λ","λ*14.70 = AFR for gasoline"], ["EQ_RATIO_ACT_mA","AFR (λ) mA","0x01","0x34","32","","","(((C*256)+D)*0.00390625)-128","mA","IN PROGRESS"], ["CAT11_DSD","Catalyst Temperature Desired","0x01","0x3C","16","","x|0.1|*|40|-","((A*256)+B)*0.1)-40","°C",""], ["PIDS_41_to_60","Supported PIDs 64 - 96","0x01","0x40","32","","","","","Bit encoded"], ["MS_DRIVE_CYCLE","Monitor Status: Drive Cycle","0x01","0x41","32","","","","","Bit encoded"], ["VPWR","Control Module Voltage","0x01","0x42","16","","x|0.001|*","((A*256)+B)*0.001","V",""], ["LOAD","Load Absolute","0x01","0x43","16","","x|0.0039215684|*","((A*256)+B)*0.0039215684","%",""], ["EQ_RATIO_DSD","Lambda Commanded","0x01","0x44","16","","x|0.00003051757812|*","((A*256)+B)*0.00003051757812","λ",""], ["TP_REL","Throttle Position Relative","0x01","0x45","8","","x|0.3921568627|*","A*0.3921568627","%",""], ["AAT","Ambient Air Temperature","0x01","0x46","8","","x|40|-","A-40","°C",""], ["TP2","Throttle Position 2 Absolute","0x01","0x47","8","","x|0.3921568627|*","A*0.3921568627","%",""], ["APP1","APP Sensor 1","0x01","0x49","8","","x|0.3921568627|*","A*0.3921568627","%",""], ["APP2","APP Sensor 2","0x01","0x4A","8","","x|0.3921568627|*","A*0.3921568627","%",""], ["ETC_DSD","Throttle Position Desired (duty)","0x01","0x4C","8","","x|0.3921568627|*","A*0.3921568627","%",""], ["DTC_CNT","# of DTCs","0x22","0x200","8","","x","A","",""], ["DTC_CNTD","# of DTCs (on demand)","0x22","0x202","8","","x","A","",""], ["MAP_V","Manifold Absolute Pressure Voltage","0x22","0x900","16","","x|0.001|*","((A*256)+B)*0.001","V",""], ["APP1_V","APP Sensor 1 Voltage","0x22","0x914","16","","x|0.001|*","((A*256)+B)*0.001","V",""], ["APP2_V","APP Sensor 2 Voltage","0x22","0x915","16","","x|0.001|*","((A*256)+B)*0.001","V",""], ["TP1_V","Throttle Position 1 Voltage","0x22","0x917","16","","x|0.001|*","((A*256)+B)*0.001","V",""], ["TP2_V","Throttle Position 2 Voltage","0x22","0x918","16","","x|0.001|*","((A*256)+B)*0.001","V",""], ["ETC_DSD_DEG","Throttle Control Desired (degrees)","0x22","0x91A","16","","x|0.001953125|*","((A*256)+B)*0.001953125","(angle)°",""], ["ETC_ACT_DEG","Throttle Position Actual (degrees)","0x22","0x93C","16","","x|0.001953125|*","((A*256)+B)*0.001953125","(angle)°",""], ["FAN3_SW","Cooling Fan Relay Control","0x22","0x967","1","2","x","","off / on",""], ["GEN_CHRGLP","Generator Warning Light","0x22","0x968","1","0","x","","off / on",""], ["IDLE","Idle Speed","0x22","0x96E","16","","x|0.25|*","((A*256)+B)*0.25","",""], ["GEN_DSD_V","Generator Voltage Desired","0x22","0x97C","16","","x|0.00048828125|*","((A*256)+B)*0.00048828125","V",""], ["EGRP_STEPS","EGR Purge Steps","0x22","0x98E","16","","x","","steps",""], ["PID_09D3_DISABLED","","0x22","0x9D3","16","","","","",""], ["ACCS_SW","A/C Relay","0x22","0x1101","1","0","x","","off / on",""], ["BOO_SW","Brake On/Off Switch","0x22","0x1101","1","1","x","","off / on",""], ["INGEAR_SW","In Gear Switch","0x22","0x1101","1","3","x","","off / on",""], ["PSP_SW","Power Stearing Position Switch","0x22","0x1101","1","7","x","","off / on",""], ["PID_1102","","0x22","0x1102","8","","","","",""], ["FAN1_SW","Cooling Fan Relay Control","0x22","0x1103","1","2","x","","off / on",""], ["FAN2_SW","Cooling Fan Relay Control","0x22","0x1103","1","3","x","","off / on",""], ["IMRC_SW","Intake Manifold Runner Control","0x22","0x1103","1","4","x","","off / on",""], ["MIL_SW","Malfunction Indicator Lamp","0x22","0x1103","1","5","x","","off / on",""], ["AC_REQ_SW","A/C Refrigerant Pressure Switch","0x22","0x1104","1","0","x","","off / on",""], ["PID_1111","","0x22","0x1111","16","","","","",""], ["IAT_V","Intake Air Temp Voltage","0x22","0x114A","16","","x|0.001|*","((A*256)+B)*0.001","V",""], ["ECT_V","Engine Coolant Temp Voltage","0x22","0x114D","16","","x|0.001|*","((A*256)+B)*0.001","V",""], ["TPCT","Throttle Position Closed Voltage","0x22","0x1169","16","","x|0.015625|*","((A*256)+B)*0.015625","V",""], ["O2S12_A_V","","0x22","0x1174","16","","x|0.0009765625|*","((A*256)+B)*0.0009765625","V",""], ["MAF_V","Mass Air-Flow Voltage","0x22","0x1177","16","","x|0.001|*","((A*256)+B)*0.001","V",""], ["APP","Accel Pedal Position (full range)","0x22","0x1340","8","","x|0.3921568627|*","A*0.3921568627","%",""], ["FUEL_PW","Injector Fuel Pulse Width","0x22","0x1410","16","","x|0.0079999994|*","((A*256)+B)*0.0079999994","",""], ["IMTV_SW","Variable Intake Air Control","0x22","0x160D","1","1","x","","off / on",""], ["O2S_HTR11_SW","O2 Sensor 1 Heater Control (Front)","0x22","0x1631","1","0","x","","off / on",""], ["O2S_HTR12_SW","O2 Sensor 2 Heater Control (Rear)","0x22","0x1631","1","1","x","","off / on",""], ["O2S12_FT","Rear O2 Sensor Fuel Trim","0x22","0x163E","16","","x|0.012207031|*","((A*256)+B)*0.012207031","%",""], ["PID_1681_DISABLED","","0x22","0x1681","8","","","","",""], ["BARO_V","BARO Sensor Voltage","0x22","0x16B3","16","","x|0.001|*","((A*256)+B)*0.001","V",""], ["VT_ACT","Valve Timing Actual","0x22","0x16CD","16","","x|0.0625|*","((A*256)+B)*0.0625","°",""], ["VT_DIFF","Valve Timing Error","0x22","0x16CE","16","","x|0.0625|*","((A*256)+B)*0.0625","°",""], ["VT_DUTY","Valve Timing OCV Control Duty","0x22","0x16CF","16","","x|0.003051757812|*","((A*256)+B)*003051757812","%",""], ["GEN_FC","Generator Field Coil Control Duty","0x22","0x16E8","16","","x|0.003051757812|*","((A*256)+B)*003051757812","%",""], ["GEN_V","Generator Output Voltage","0x22","0x16E9","16","","x|0.125|*","((A*256)+B)*0.125","V",""], ["TIRESIZE","Tire Revolutions Per Mile","0x22","0x16F0","16","","x","(A*256)+B","rev/mi",""], ["HIDET_SW","High Detonation Switch","0x22","0x1706","1","0","x","","off / on",""], ["LAMBDA_MOD_SW","Lambda Modification Switch","0x22","0x1706","1","6","x","","off / on",""], ["PID_1708","","0x22","0x1708","8","","","","",""], ["PID_1710","","0x22","0x1710","56","","","","",""], ["FP_RELAY_SW","Fuel Pump Relay Switch","0x22","0x1718","1","0","x","","off / on",""], ["PID_171E","","0x22","0x171E","8","","","","",""], ["PID_171F","","0x22","0x171F","8","","","","",""], ["PID_1721","","0x22","0x1721","16","","","","",""], ["PID_1722","","0x22","0x1722","16","","","","",""], ["PID_1724","","0x22","0x1724","8","","","","",""], ["PID_172E","","0x22","0x172E","32","","","","",""], ["PID_1730","","0x22","0x1730","32","","","","",""], ["PID_1735","","0x22","0x1735","8","","","","",""], ["PID_1736","","0x22","0x1736","8","","","","",""], ["PID_1737","","0x22","0x1737","8","","","","",""], ["PID_173B","","0x22","0x173B","32","","","","",""], ["KNOCKR","Knock Retard","0x22","0x1746","8","","x|0.3521126761|*","A*0.3521126761","(retard)°",""], ["PID_174E","","0x22","0x174E","8","","","","",""], ["PID_174E","","0x22","0x174E","8","","","","",""], ["PID_174F","","0x22","0x174F","8","","","","",""], ["LDP_VSL_DV","EVAP LDP Very Small Leak Detect Value","0x22","0x176B","16","","x|0.0000053405761|*","((A*256)+B)*0.0000053405761","mA/sec",""], ["LDP_VSL_SV","EVAP LDP Very Small Leak Safe Value","0x22","0x179A","16","","x|0.0000053405761|*","((A*256)+B)*0.0000053405761","mA/sec",""], ["PID_17A6","","0x22","0x17A6","8","","","","",""], ["LDP_MON_current","EVAP LDP Monitoring Current","0x22","0x17F4","16","","x|0.00000056098486|*","((A*256)+B)*0.00000056098486","A",""], ["LDP_REF_current","EVAP LDP Reference Current","0x22","0x17F5","16","","x|0.00000056098486|*","((A*256)+B)*0.00000056098486","A",""], ["LDP_IDL_current","EVAP LDP Idle Current","0x22","0x17F7","16","","x|0.00000056098486|*","((A*256)+B)*0.00000056098486","A",""], ["LDP_SL_DV","EVAP LDP Small Leak Detect Value","0x22","0x17F8","16","","x|0.00000056098486|*","((A*256)+B)*0.00000056098486","A",""], ["LDP_VSL_FV","EVAP LDP Very Small Leak Fail Value","0x22","0x17F9","16","","x|0.0000053405761|*","((A*256)+B)*0.0000053405761","mA/sec",""], ["LDP_EVAPCP","EVAP LDP Incorrect Purge Flow Value","0x22","0x17FA","16","","x|0.00000056098486|*","((A*256)+B)*0.00000056098486","A",""], ["CPP_SW","Clutch Pedal Position Switch","0x22","0xA211","1","0","x","","off / on",""], ["BPA_SW","Brake Pressure Applied Switch","0x22","0xA211","1","1","x","","off / on",""], ["PNP_SW","Park Neutral Position Switch","0x22","0xA211","1","2","x","","off / on",""], ["IVS_SW","Idle Validation Switch","0x22","0xA211","1","4","x","","off / on",""], ["SCCS_V","Cruise Control Voltage","0x22","0xA216","16","","x|0.0000762951095|*","((A*256)+B)*0.0000762951095","V","0.0V = On/Off Switch depressed"] ] function main() { add_table(can_data, 'cans') add_table(obd_data, 'obds') } function decode_modifier(str) { var res = str.split("|"); var f = {} f['add']=0 f['mult']=1 f['div']=1 if( res.length == 1) { } else if( res.length == 3) { if(res[2] == '*') { f['mult']=res[1] } else if(res[2] == '-') { f['add'] = -res[1] } else if(res[2] == '+') { f['add'] = res[1] } else { alert(str) } } else if( res.length == 5 ) { if( res[2] == '-' && res[4] == '*') { f['add'] = -res[1]*res[3] f['mult'] = res[3] } else if( res[2] == '+' && res[4] == '*') { f['add'] = res[1]*res[3] f['mult'] = res[3] } else if( res[2] == '*' && res[4] == '+') { f['add'] = res[3] f['mult'] = res[1] } else if( res[2] == '*' && res[4] == '-') { f['add'] = -res[3] f['mult'] = res[1] } else if( res[2] == '*' && res[4] == '*') { f['div'] = 1/res[3] f['mult'] = res[1] } else { alert(str) } } else { alert(str) } return f; } function add_table(data,table_name) { tbl = document.getElementById(table_name); var i; for(i=0;i<data.length;i=i+1) { if( data[i][8] == '%' ) { data[i][10] = 0 data[i][11] = 100 data[i][12] = 0 } else if( data[i][8] == 'rpm' ) { data[i][10] = 0 data[i][11] = 10000 data[i][12] = 0 }// else if( data[i][8] == 'V' ) { data[i][10] = 0 data[i][11] = 15 data[i][12] = 1 } else if( data[i][8] == 'λ' ) { data[i][10] = 0 data[i][11] = 2 data[i][12] = 2 } else if( data[i][8] == '(angle)°' ) { data[i][10] = -180 data[i][11] = 180 data[i][12] = 0 } else if( data[i][8] == '(retard)°' ) { data[i][10] = -180 data[i][11] = 180 data[i][12] = 0 } else { data[i][10] = 0 data[i][11] = 9999 data[i][12] = 2 } addRow(tbl, data[i],i,table_name); } write_obd( obd_data[4] ) } function addCell(tr, val) { var td = document.createElement('td'); td.innerHTML = val; tr.appendChild(td) } function addRow(tbl, val_1,id,table_name) { var tr = document.createElement('tr'); var i; var checkname= table_name + "_check"+id; addCell(tr,val_1[0]) addCell(tr,val_1[1]) addCell(tr,val_1[2]) addCell(tr,val_1[3]) addCell(tr,val_1[10]+"/"+val_1[11]+"/"+val_1[12]) var inp = document.createElement("INPUT"); inp.setAttribute("id",checkname); inp.setAttribute("type", "checkbox"); tr.appendChild(inp) //addCell(tr,inp) tbl.appendChild(tr) } var first_json function start_json() { first_json = true } function write_json( f, t ) { if(!first_json) { t=t+",\n" } first_json = false var first=true t=t+"{\n" for(var i in f) { if(!first) { t=t + ",\n"; } first=false t=t + ' "'+i+'" : ' + f[i] } t=t+"\n}\n" return t } function write_can(data,t) { f=decode_modifier(data[6]) f['nm'] = '"' + data[0] + '"' f['bigEndian'] = true f['bm'] = false f['bus'] = 2 f['filtId'] = 0 f['id'] = data[2] f['idMask'] = 0 f['len'] = data[4] / 8 f['max'] = data[10] f['prec'] = data[12] f['min'] = data[11] f['sr'] = 50 f['subId'] = -1 f['type'] = 0 f['ut'] = '""'; t=write_json(f,t) return t } function write_obd(data,t) { f=decode_modifier(data[6]) f['nm'] = '"' + data[0] + '_OBD"' f['bigEndian'] = true f['bm'] = false f['bus'] = 2 f['filtId'] = 0 f['id'] = 2024 f['idMask'] = 0 f['len'] = data[4] / 8 f['max'] = data[10] f['mode'] = parseInt(data[2],16) f['prec'] = data[12] f['min'] = data[11] f['sr'] = 10 f['offset'] = 0 f['pid'] = parseInt(data[3],16) f['pass'] = false f['subId'] = -1 f['type'] = 0 f['ut'] = '""'; t=write_json(f,t) return t } function generate() { var i; t="" start_json() for(i=0;i<obd_data.length;i=i+1) { if( document.getElementById('obds_check'+i).checked ) { t=write_obd( obd_data[i],t ) } } document.getElementById("obddata").innerHTML = t start_json() t="" for(i=0;i<can_data.length;i=i+1) { if( document.getElementById('cans_check'+i).checked ) { t=write_can( can_data[i],t ) } } document.getElementById("candata").innerHTML = t } #obds { font-family: "Trebuchet MS", Arial, Helvetica, sans-serif; border-collapse: collapse; width: 100%; } #obds td, #obds th { border: 1px solid #ddd; padding: 8px; } #obds tr:nth-child(even){background-color: #f2f2f2;} #obds tr:hover {background-color: #ddd;} #obds th { padding-top: 12px; padding-bottom: 12px; text-align: left; background-color: #1122A0; color: white; } #cans { font-family: "Trebuchet MS", Arial, Helvetica, sans-serif; border-collapse: collapse; width: 100%; } #cans td, #cans th { border: 1px solid #ddd; padding: 8px; } #cans tr:nth-child(even){background-color: #f2f2f2;} #cans tr:hover {background-color: #ddd;} #cans th { padding-top: 12px; padding-bottom: 12px; text-align: left; background-color: #1122A0; color: white; } Choose Bus: CAN1 CAN2
CAN
Parameter Name Description Mode Mode PID Min/Max/P
OBD
Parameter Name Description Mode Mode PID Min/Max/P

Generate

CAN DATA

candata

OBD DATA

obddata

This write up describes how to install RCP on a 1.6 Miata. The following sensors are connected to RCP:

• RPM
• Coolant Temp
• Fuel
• TPS
• Brakepos

There is no CAN on the 1.6. To get data from the sensors you have to "tap into" the sensors. Therefor you either need the Pro version that has Digital and Analog inputs or you need the Track version with a AnalogX.
Some of this might apply for the 1.8, the 2.0 has CAN and none of this is relevant.

Having this, https://www.miataforumz.com/1990-200-Miata-Wiring/90diag.pdf is useful.

Mounting I decided to mount my RCP on the transmission tunnel. My car is a Harris Hill Challenge Series race car so there is no interior to care about. To make it fit nice I decided to rotate it 90 degrees, if you do this you need to swap the X/Y axis in the App.


Power I prefer to have the Race Capture powered on even if the ignition is off. That way you get accurate logging even if you need to restart the car (due to spin out, spit stop, etc).  From the engine fusebox you can get fused circuits that are always on. There is a BLUE/YELLOW wire comming out of the fusebox that I connected to the RCP via a switch.
It's not recommended to connect it directly to the battery without a fuse. 
A simpler solution is to just use a battery pack via the USB.

RPM / Coolant / Fuel from instrument cluster
On my car it's relatively easy to access the instrument cluster and tap into those wires. There are two connectors on the back of the instrument cluster that feeds the various gauges. The instrument cluster also has some information printed on the circuit board, that can be used as an extra check. The instrument cluster has two connectors, the left one (from driver) is labeled "1" in the wiring diagram and the right one is labeld "2" in the wiring diagram. Each wire within the connector is labeled by a letter.
RPM The RPM signal is taken directly from the tach input. This wire is not used by the ECU so you don't risk of messing with the engine management. 
Tap into the 1H wire, that is the YELLOW/BLUE wire on the left connector. Connect it to one of the pulse inputs.
Fuel Tap into the 1A wire, that is the YELLOW wire on the left connector. Connect it to one of the analog inputs.  The input is not linear so you need the following mapping for the sensor:
9.4v = 0%
7.5v = 25%
5.1v = 50%
3.0v = 75%
0.7v = 100%


Coolant This taps from the sensor that goes into the gauge cluster, the ECU uses a different sensor.  Tap into the 2L wire, that is a BLACK/BLUE wire on the right connector. Connect it to one of the analog inputs. The input is not linear so you need the following mapping for the sensor:
8.2v = 144F
5.3v = 180F
4.1v = 198F
2.2v = 235F
1.6v  = 260F
It's recommended that you calibrate these values! There seems to be a large discrepancy. 

As you can see the fuel and coolant temp goes over 5v, so you will not be able to monitor fuel levels below ~50%, or coolant colder than ~180F. 
You could use an opamp to "amplify" the signal to a smaller value. You could also put a diode if you want to shift the span.
I haven't tested the higher coolant temp values, these are just based on the data for the sensor.
For more accurate readings it would be better to use the regulated 5v provided by the race capture, but this makes you stock gauge unsuable.

At least for the coolant it uses an unregluated voltage to calulcate the temps, so the temperature will depend on the alternator voltage. 


TPS The 1.6 Miata TPS is more of a switch than a linear position sensor. With the TPS you can only monitor WOT, Partly Open and Closed. You can either tap into the wires directly at the ECU or at the sensor, accessing the ECU is easy on my car. Tap into the RED N wire from the right connector of the ECU and connect to a analog input. Tap into the GREEN/WHITE  L wire from the left connector of the ECU and connect to a analog input.
Add the following script:
setTickRate(25)
tps_id = addChannel("TPS",10,0,0,100,"%")
function onTick()    local not_wot = getAnalog(3)    local pressed = getAnalog(4)
   if     not_wot == 1 and pressed == 0 then      setChannel (tps_id,0)    elseif not_wot == 1 and pressed == 1 then      setChannel (tps_id,50)    elseif not_wot == 0 and pressed == 1 then      setChannel (tps_id,100)    end   
end

Make sure you get the correct wires, the arrows shows what RED wire and what GREEN/WHITE:
Brake Position There is no brake pressure sensor in the Miata. I just connected to the brake light in the rear. Tap into the GREEN wire on the tail light and connect to a digital input.

The last few days I spend some time on porting the beloved game DOOM to the ZPU CPU. For you who don't know what I am talking about, DOOM was a ground breaking game released in early 90. ZPU is not only a russian AA gun but also a 32 bit open source CPU

DOOM v1.666 running in ZPU simulator.
So what is the point of doing this?
Well, it is just for fun I guess. A ZPU based game console will have a hard time to beat the next Xbox 720 or PS4. Infact the ZPU is pretty slow and not very well suited for graphics.
Having that said, DOOM on ZPU is interesting from a profiling and verification point. Without any hard evidence I would say DOOM is a more interesting work load than Dhrystone. It also tests the toolchain and hardware quite a bit.





Mr DOOM in trouble  To summarize these are the leanings/status:

• With HW acceleration it is possible to play DOOM on FPGA
• long long operations and memcpy are not very great with the current toolchain
• Port is running modified Phi platform
• This is only tested in emulator

The following is currently not supported in the port:

• Sound 
• Input
• Network

I currently don't have a FPGA board so I have only run it inside the ZPU simulator, this gets you about 1-2 FPS on a decent laptop. So not very playable, therefor I didn't bother with input or sound.

Some add-ons to the Phi platform was needed:

• Mode 13 frame buffer
• Doom1.wad preloaded into memory
• 35Hz timer

Performance So how fast is DOOM on ZPU?  With the following setup:

• All instructions implemented
• 225 MHz 
• Loads takes 2 cycles (i.e no RAM latency)

At 225 MHz an average 30.5 FPS with some rare 20-25 FPS are achieved when running 'timedemo demo3'. Resolution is the default Doom, 320x200.
To reach the same performance on a PC something like a 486 @ 66MHz and a decent graphics card is needed. Look at this great benchmark list.
So is the ZPU about 1/4 the speed of a 486?
No, the comparison is a bit unfair:

• In simulation the frame buffer has no latency, this is NOT true for computers from the 486 era. A good graphics card could almost double FPS.
• ZPU port does not have any sound. 
• RAM access has 1 cycle latency in simulation, this is far from true for an old PC.

The x86 port has assembly optimizations for the inner loops, the ZPU port is C code only.

It would be hard to reach >100 MHz on a FPGA, as far as I know all ZPU implementations barley reach 100 MHz. But with some tricks it would still be possible to achieve decent performance (see profiling for details):

• Some of the inner loops and fixed point arithmetic could be replaced by hardware units.
• There is a frame buffer memcpy done every frame, this could be removed if a double buffering capable display controller is used.
• The 64 kB frame buffer could reside in a dualport onchip RAM. This would give a very fast frame buffer.

Profiling The DOOM demo mode is very similar to real game play, the demo mode is normal game play but with key strokes recorded. Demo runs will be deterministic. The profiling has been run using the command line:
-timedemo demo3
(Again, taken from this. They are running the original DOOM port. The ZPU port is ported from BOOM.)
Time spent in each frame as FPS. The workload varies much between frames. Frame 1137, 76 FPS. Fastest frame. No time spent in ceiling or floor. Little time spent in drawing walls.

Frame index 184, 14 FPS. Slowest frame. Way more fixed point multiplications than surrounding frames, not sure why.

A typical frame takes about 7400000 cycles with the ZPU platform described above. Stairs, enemies, shooting and transparency are some things that will increase render time. The table below contains a breakdown for frame 200 of the demo run, this frame is good typical frame. The frame takes 9562694 cycles to complete.

Function Name Total cycles spent Nbr calls Avg time in call Description memcpy (all) 1414058  5356263All memcpy calls memcpy (framebuffer) 224504 1 224504 memcpy to framebuffer udivsi3 2753956 1578 1745 long long div muldi3 2073756 2322 893 long long mult R_Drawspan 837281 161 5200 Draw ceiling/floor R_DrawColumn 647947 867 747 Draw walls (This is just for frame 200 but other frames should be somewhat similar)

There seems to be something fishy here.The majority of time should be spend inside the R_DawSpan and R_DrawColumn functions, these are the functions that does all the pixel drawing. Instead most time is spend doing 64bit arithmetic.
(See http://fabiensanglard.net/doomIphone/doomClassicRenderer.php for some interesting profiling results).


Frame 200. Used for function call profiling. udivsi3 & muldi3 DOOM uses 64 bit multiplications as part of their fixed point arithmetic. Many old PCs lacked an FPU I believe this is the reason why DOOM is integer only.

#define FRACBITS 16

__inline__ static fixed_t FixedMul(fixed_t a, fixed_t b)
{
  return (fixed_t)((long long) a*b >> FRACBITS);
}

__inline__ static fixed_t FixedDiv(fixed_t a, fixed_t b) {   return (abs(a)>>14) >= abs(b) ? (a^b)<0 ? MININT : MAXINT :     (fixed_t)(((long long) a << FRACBITS) / b); }
The ZPU does not have support for 64bit hardware multiplication or division so the compiler relies on a software to implement the long long operations. A multiplication takes almost 900 cycles, 400 of those cycles are spent inside two 8 byte memcpy. The division routine has a similar behavior.
There is plenty of room for improvement in these routines. A good approach would be to do a  assembler optimized routine. Better but not portable would be to use a dedicated hardware for the fixed functions above. FPGAs usally has a lot of multipliers in them that can be used for the multiplication. Many FPGA vendors supply IPs for dividers, there are also some available on opencores.com
These hardware blocks would then be memory mapped, this would be easier than adding a new instruction to the instruction set. The hardware accelerated multiplier would be very quick the divider a bit slower.
Including function overhead the FixedMul could take less than 50 cycles and the FixedDiv less than 100 cycles, but this is just a very wild guess.

memcpy If the Fixed functions are improved then the majority of the time spend in memcpy will disappear.
The memcpy complexity is approximently:

cycles_in_memcpy = 200 + bytes_to_copy *3.5;

Any small copy will have a pretty large overhead and large copies aren't that fast either. I am having trouble locating what memcpy being used, the only one I can find is this (zpugcc/toolchain/binutils/libiberty/bcopy.c):
void
bcopy (src, dest, len)
  register char *src, *dest;
  int len;
{
  if (dest < src)
    while (len--)
      *dest++ = *src++;
  else
    {
      char *lasts = src + (len-1);
      char *lastd = dest + (len-1);
      while (len--)
        *(char *)lastd-- = *(char *)lasts--;
    }
}
When looking at the assembler the doesn't look very similar, however GCC might unroll the loops. The frame buffer memcpy takes about 2-3% of a frame, this could be removed completely by using hardware double buffering.
I have seen several post about optimized memcpy for ZPU, has anyone of  these reached the repository?

R_DrawColumn & R_DrawSpan These are the functions that most time should be spent into. These functions draw the pixel values to the framebuffer (via a buffer). R_Drawcolumn draws the walls and R_Drawspan draws the floors and ceiling, (see http://fabiensanglard.net/doomIphone/doomClassicRenderer.php for a good explanation)
This is one of the innerloops inside R_Drawcolumn:

do
{
  // Re-map color indices from wall texture column
  //  using a lighting/special effects LUT.

  // heightmask is the Tutti-Frutti fix -- killough

  *dest = colormap[source[frac>>FRACBITS]];
  dest += SCREENWIDTH;
  if ((frac += fracstep) >= heightmask)
    frac -= heightmask;
}
while (--count);    
This loop would be a good candidate for hardware acceleration. The software would not need to wait for the hardware accelerated loop to finish, instead it could go on and do other things.
Each iteration takes about 30 cycles and the count value varies greatly but for this particular frame the average value is about 20. So around 600 cycles could be saved.
The R_drawspan has a similar but not identical inner loop that would also benefit greatly from hardware acceleration.

There is plenty of room for optimizations, software only optimizations would give a nice bump but HW acceleration is needed to reach 35 FPS on a FPGA board clocked at 50 MHz.

OP code histogram The emulator has a nice opcode histogram feature, this is useful to get an understanding of the workloads.
A first guess might be that a 3D game would have a pretty characteristic profile when it comes to what instructions being used most. One might suspect lots of multiplications and divisions, but this is not the case.
Scroll down for a complete list of the opcode histogram. This histogram calculated from the entire run not just frame 200.
Here are some comments regarding some of the instructions:

loadsp / storesp / addsp  The most common instructions are what I call the stack operation instructions these are loadsp, storesp and addsp. I use to think of them as a necessity due to the lack of registers, or they being the equivalent to registers in a register based architecture. In most workloads these will always be among the most common instructions.
This is a typical example:
count = dc_yh - dc_yl; 
   32798: 73           loadsp 12
   32799: 76           loadsp 24
   3279a: 31           sub
   3279b: 55           storesp 20

The register based architecture would have something like:         sub r20, r24,r12  // substract r12 from r24 and store in r20
load 32bit load is a very common instruction at 12.5%. 32bit loads are used for accessing arrays and global variables. There are many global variables in the code. These are often used in combination with the im instruction:

  fracstep = dc_iscale; 
   32532: af           im 47    
   32533: 99           im 25
   32534: c8           im -56
   32535: 08           load  // load from bccc8
00032536 <.LM6>:
  frac = dc_texturemid + (dc_yl-centery)*fracstep; 
   32536: 79           loadsp 36
   32537: af           im 47
   32538: b0           im 48
   32539: a4           im 36
   3253a: 08           load // load from bd824
   3253b: 31           sub
   3253c: 71           loadsp 4
   3253d: 29           mult
   3253e: af           im 47
   3253f: a0           im 32
   32540: 80           im 0
   32541: 08           load // load from bd000
   32542: 05           add
00032543 <.LM7>:
    register const byte *source = dc_source;            
   32543: af           im 47
   32544: 99           im 25
   32545: c4           im -60
   32546: 08           load // load from bccc4

All global variables are located close in memory but they are all fetched using absolute addresses. IMs are  used to describe the absolute addresses. In fact almost all arrays and global variables are loaded using 3 im to address them. Even if most global variable are close together
It would be nice to have something like a frame pointer and then a relative load.

   im 47     // set fp to at bccc4
   im 25
   im -60
   popfp
 fracstep = dc_iscale;    
   im -1
   loadfprel // load from bccc8

 frac = dc_texturemid + (dc_yl-centery)*fracstep; 
   loadsp 36
   im 5
   im 80
   loadfprel // load from bd824
   sub
   loadsp 4
   mult
   im 1
   im 79
   loadfprel // load from bd000

 register const byte *source = dc_source;            
   im 0
   loadfprel // load from bccc4
In the above example 3 instructions would be saved using a loadfprel instruction.
(To clarify, there is no such function. But it might be a good addition if there ever is a ZPUv2)

loadb Most pixel operations are done using char*, these will in most cases use loadb. It is surprising to see that loadb is only 1.7% given that this instruction is executed a lot in the inner loops of R_Drawxxxx functions.



Opcode histogram for all frames

im 32.99% storesp 12.77% load 12.49% loadsp 8.39% add 9.35% addsp 4.22% neqbranch 3.17% store 2.79% loadb 1.76% eq1.39% and 1.28% storeb 1.16% lshiftright 0.98% ashiftright 0.61% not 0.56% sub 0.54% lessthanorequal 0.53% mult 0.51% poppcrel 0.51% lessthan 0.50% nop 0.47% pushspadd 0.36% ulessthanorequal 0.35% ulessthan 0.35% popsp 0.33% or 0.33% poppc 0.21% ashiftleft 0.16% loadh 0.15% callpcrel 0.15% pushsp 0.06% call 0.05% storeh 0.05% flip 0.02% xor 0.01% neg 0.009%
What is next? It would be nice to port this to FPGA. Preferably to an already existing enviroment. Maybe the ZPUIno? Some things that the platform needs to handle:

• Code size is  ~700kB
• File data is ~4 MB 
• 4MB RAM (either onchip or offchip+cache)
• Display output (VGA/HDMI, preferably 6bits per plane)
• FPGA resources for a Mode 13 frame buffer