; Disassembly of an EE88 EPROM ; assembler file for RhinoPower IDE ; James Holland ; www.rhinopower.org ; Updated: 21st Nov 2013 ; ; This file has been editted in MiniIDE ; font=Courier ; Font size=10 ; ; ; ; #include MOTO.H ; ; ****************************************************** ; ; Register definitions ; ; ****************************************************** ; org $0000 ; P1DDR equ $00 P2DDR equ $01 PORT1 equ $02 ; PORT1 ; 5 = ???? ; Bit 3 = ???? ; PORT2 equ $03 ; Maybe the analogue channels? P3DDR equ $04 ; PORT3 DDR P4DDR equ $05 ; PORT4 DDR PORT3 equ $06 ; PORT3 ; on port expander ; Bit7 = Idle ; Bit6 = ? ; Bit5 = D/P-N? ; Bit4 = Oil Pressure Switch ; Bit3 = Power Steering Switch ; Bit2 = Test Switch Term. ; Bit1 = Diag. Switch Term. ; Bit0 = ? ; PORT4 equ $07 ; PORT4 ; on port expander ; bit7 = R328 ECU Config resistor | R328, 329, 330 ; Bit6 = R329 ECU Config resistor | set L00D7 (via LUT) ; Bit5 = R330 ECU Config resistor | ; Bit4 = R331 ECU Config resistor sets L00D2 bit 7 ; Bit3 = EGR ; Bit2 = EGR ; Bit1 ; Bit0 = IGS 0 = ignition On, 1 = ignition off T1CSR equ $08 ; T1CSR - Timer 1 control and status TMR1H equ $0009 ; Timer 1 OCR1H equ $000B ; Output Compare 1 register ICR1H equ $000D ; Input Capture 1 register P3CSR equ $0F ; PORT3CSR - Port3 Control and Status Register RMCR equ $10 ; SCI Rate and Mode Control Register SCICR equ $11 ; Serial Communications Interface (SCI) control register SCIRX equ $12 ; SCI RX Register SCITX equ $13 ; SCI TX register RAMCR equ $14 ; RAM Control Register P5DDR equ $15 ; PORT5 DDR PORT5 equ $16 ; PORT5 ; Bit 7 = SCK ; Bit 6 = SDA ; Bit 1 = ? ; Bit 0 = ? L0017 equ $17 ; Unimplemented T2CSR equ $18 ; T2CSR Timer 2 Control and Status Register T3CSR0 equ $0019 ; T3CSR0 T3CSR1 equ $001A ; T3CSR1 T2OCRH equ $001B ; T2OCR T2ICRH equ $001D ; T2ICR L001F L0020 L0021 L0022 L0023 L0024 L0025 L0026 ; RTI Control Register L0027 ; RTI Frequency Control Register L0028 TMR3 equ $0029 ; Timer 3 L002B equ $002B ; T3OCR L002D equ $002D ; Timer3 ?? PORT6 equ $002F ; is PORT6 ; Bit 5 = Watchdog Timer Reset ; Bit 3 = unknown ; Bit 2 = Fuel Pump P7DDR equ $30 ; PORT7 DDR PORT7 equ $31 ; PORT7 ; Bit 7 = Check Engine Light ; Bit 6 = unknown ; Bit 5 = unknown (O2 heater?) ; Bit 1 = EGR ; Bit 0 = EGR L0032 equ $0032 L0033 equ $0033 L0034 equ $0034 L0035 equ $0035 L0036 equ $0036 L0037 equ $0037 ; ADCCR equ $38 ; ADC Control Register ; L0039 L003A L003B L003C ADCRSLT equ $3D ; ADC Result Register L003E L003F ; ; ; ****************************************************** ; ; EE88 RAM allocations ; ; ****************************************************** ; ; Baro_x equ $40 ; Barometric Pressure (RAW_MAP * 1024) + something TPS_Idl equ $41 ; TPS Idle - idle Switch opening position? L0042 equ $0042 I2CSR equ $43 ; bit banged I2C Status Register? ; TX or RX in progress?? FCodes0 equ $44 ; Fault Codes 0 (current) ; Bit7 - IAT Low (Code 25) ; Bit6 - VSS (Code 24) ; Bit5 - IAT High (Code 23) ; Bit4 - TPS Low (Code 22) ; Bit3 - TPS High (Code 21) ; Bit2 - WTS (Code 15) ; Bit1 - WTS (Code 14) ; Bit0 - O2 Sensor (Code 13) FCodes2 equ $45 ; Fault Codes 2 (History) ; flags same as L0044 FCodes1 equ $46 ; Fault Codes 1 (current) ; Bit7 - GND Circuit (Code 53) ; Bit6 - EGR (Code 51) ; Bit5 - Idle Switch (Code 45) ; Bit4 - Idle Switch (Code 44) ; Bit3 - CMP (Code 42) ; Bit2 - IFS (Code 41) ; Bit1 - MAP Low (Code 32) ; Bit0 - MAP High (Code 31) Fcodes3 equ $47 ; Fault Codes 3 (History) ; flags same as L0046 ImmoSR equ $48 ; Immo/SEEPROM status ; Bit 3 = I2C fail ; Bit 1 = codes not matched? ; Bit 0 = unknown set if fault start of SUBR5, cleared in SUBR6 ; 0x00 = no fault ImmoCR equ $4B ; SEEPROM control register ; Bit7 = ? ; Bit6 = SEEPROM data at L016F, A=4? ; Bit5 = SEEPROM data at L0173, A=8? ; Bit4 = ; Bit3 ; Bit2 ; Bit1 ; Bit0 RPMH equ $004D ; RPM High (Diagnostic Address) L0051 equ $51 ; RPM modified (8-bit) L0052 equ $0052 ; not RPM ; ; ; Registers 54-5B are where the A/D results are transferred ; WTS_Raw equ $54 ; A/D ch0 WTS ARS_Raw equ $55 ; A/D ch1 ATS ADCCH2 equ $56 ; A/D ch2 Unused ADCCH3 equ $57 ; A/D ch3 Unused Bat_Raw equ $58 ; A/D ch4 Battery Volts = Batt_Raw * 0.0737288 MAP_Raw equ $59 ; A/D ch5 Manifold Absolute Pressure (MAP_Raw) O2S_Raw equ $5A ; A/D ch6 O2 Sensor TPS_Raw equ $5B ; A/D ch7 Throttle Position Sensor (TPS Volts) ; MAP_5 equ $5C ; MAP/5 MAP_x51 equ $005C ; MAP*51.2 MAP_x36 equ $005E ; MAP*36 sample T0 MAP36T1 equ $0060 ; MAP*36 sample T1 MAP36T2 equ $0062 ; MAP*36 sample T2 MAP36T3 equ $0064 ; MAP*36 sample T3 MAP equ $66 ;Manifold Pressure (diagnostic location) L0067 inits as manifold pressure L0068 inits as manifold pressure L0069 inits as manifold pressure L006A inits as manifold pressure L006B L006C ATS equ $006E ; Air Temperature TPSA equ $0070 ; TPS Angle (TPS_Raw – TPS_Base) L0071 Copy of TPS Angle L0072 Copy of TPS Angle L0073 Copy of TPS Angle L0078 STAT4 equ $0079 ; Status Flags 4 ; Bit 7 = Idle ; Bit 6 = ? ; Bit 5 = D/PN ; Bit 4 = AC Sw ; Bit 3 = PS Switch ; Bit 2 = Test Sw.Term. ; Bit 1 = Diag. Sw. Term ; Bit 0 = CEL? L0081 ; Internal Status Flags ; Bit 7 = ; Bit 6 = From L007B, bit 7 ; Bit 5 = ; Bit 4 = ; Bit 3 = ; Bit 2 = ; Bit 1 = O2 status ; Bit 0 = SensStat equ $0082 ; Sensor Status ; Bit 7 = ATS fault? ; Bit 6 = WTS fault? ; Bit 5 = TPS? ; Bit 4 = TPS? ; Bit 3 = TPS fault ; Bit 2 = ; Bit 1 = ; Bit 0 = MAP Sensor fault? Stat83 equ $0083 ; Internal Status ; Bit6 = main loop completed at least once? RTICNT equ $0084 ; RTI Counter, increment on every RTI VSS equ $0093 ; VSS (diagnostic address) O2Stat equ $0095 ; Status Flags 3 (O2 Sensor) ; Bit7 ; Bit6 ; Bit5 ; Bit4 ; Bit3 ; Bit2 ; Bit1 = rich/lean? ; Bit0 = lean/rich? IgnAdv equ $00AF ; Ignition Advance (diagnostic address) IgnDwel equ $00B1 ; Ignition Dwell Time Ign? equ $00B5 ; adds to AF to get timing value = maybe IACFlow equ $00BA ; IAC Flow ACTCR equ $00B7 ; Actuators Control register ; Bit3 = set target idle ; ; ; ; ; working registers L00C3,C4 is MAP_Raw * 256 SDLSR equ $00D2 ; Serial Link Handler status ; Bit 7 = ? ; Bit 6 = 1 = incoming message (valid header received) ; Bit 3 = ? ; Bit 0 = ?? to do with actuators? SDLCnt equ $00D3 ; Serial Link Handler - maybe byte counter SDLCS equ $00D4 ; Serial Link Handler - maybe checksum TIdle equ $00D5 ; Target Idle (diagnostic address) HWCR equ $00D7 ; Hardware Control register ; PORT4 is read and the upper 3 bits shifted to the lower 3 bits ; This is used at offset value to get D7 value from table at L9811 ; config. settings from table at L9811: ; 7 6 5 4 3 2 1 0 ; 0 20 0 0 1 0 0 0 0 0 ; 1 22 0 0 1 0 0 0 1 0 ; 2 0A 0 0 0 0 1 0 1 0 ; 3 12 0 0 0 1 0 0 1 0 ; 4 21 0 0 1 0 0 0 0 1 ; 5 23 0 0 1 0 0 0 1 1 ; 6 0B 0 0 0 0 1 0 1 1 ; 7 13 0 0 0 1 0 0 1 1 ; So on a 70E10 PCB only bits 5 and 1 are set. All others are clear. IACMon equ $00D8 ; IAC Adjust Monitor (diagnostic Address) TfStart equ $00D9 ; Time From Start (diagnostic address) WTS_Lin equ $00DF ; WTS Linear (diagnostic address) ATS_Lin equ $00E0 ; ATS Linear (diagnostic address) Stat_E6 equ $00E6 ; Status register ; Bit7 Battery Voltage, 1=low ; Bit6 1=EEPROM write, 0=EEPROM read ; Bit3 = 1? I2C test ; Bit 2 = 1, X=177, A=C ; Bit 1 = 1, X=173, A=8 ; Bit 0 = 1, X=16F, D=0404 - immobiliser codes?? TFT equ $00E1 ; Total Fuel trim LTFT equ $00EB ; Long Term Fuel trim STFT equ $00F3 ; Short Term Fuel trim L00FC, FD is Manifold pressure *n RPMH2 equ $00FE ; RPM (diagnostic address) L0100 Injector PW (?) L013A related to SEEPROM Comms L013B related to SEEPROM Comms L0152 copy of VE? L0154 something to do with ISC? CWord1 equ $0163 ; ECU Control Word 1 L0168 Copy of TPS_Raw. Used to calculate delta TPS. Cword2 equ $016D ; ECU Control Word 2 L0173,4 Immobiliser Status? L0177,8 Immobiliser Status? L0179,A Immobiliser Status? L0186 Status Flags 2 Stat187 equ $0187 ; Legacy (California EGR fault codes) ; Bit2 - EGRT Open cct (Code 51) ; Bit1 - EGRT Short cct (Code 51) ; Bit0 - EGR (Code 51) Stat188 equ $0188 ; Status Flags 1 ; ; ; CAS Buffer ; CAS_T0 equ $0224 ; CAS (T=0) CAS_T1 equ $0226 ; CAS (T-1) CAS_T2 equ $0228 ; CAS (T-2) CAS_T3 equ $022A ; CAS (T-3) ;SCI data buffer ; SDLHdr equ $022C ; Msg Header SDLLen equ $022D ; Msg Length SDL_B0 equ $022E ; data byte 0 . . . SDL_Bx equ $022x ; bytex ; ; ; ; The rest of the RAM is available to the stack ; ; TOPSTK equ $043F ;top of stack ; ; ; ****************************************************** ; ; Data Tables start here at $8000 ; ; ****************************************************** ; org $8000 ; db $FF, $FF, $FF, $FF, $FF, $FF, LUT_8006: db $3B, $F6 db $FF, $FF ; fill 3850, $FF fill 236, $FF ; ; ;EEPROM I.D. PROM_ID: db $EE, $88 ;Unknown LUT_9002: db $28, $23, $16, $0A, $03, $00, $00, $00 ;or LUT_900A: db $35, $2B, $16, $0A, $03, $00, $00, $00 ;Table look up (MAP v WTS) v RPM LUT_9012 db $2C, $2C, $2C, $40, $64, $80, $8D, $9A LUT_901A db $9A, $9A, $9A, $9A, $9A, $9A ;9020 - Fuel Map 1 (16 x 16) F_MAP1: db $A0, $A0, $A0, $A3, $A4, $A3, $9C, $95 db $90, $8A, $85, $80, $7A, $6A, $65, $65 db $A4, $A6, $AD, $AE, $AE, $B4, $AC, $A3 db $A0, $9C, $99, $95, $80, $6C, $67, $67 db $A6, $AA, $B0, $B1, $B2, $B5, $B2, $AD db $AC, $AB, $A3, $9B, $85, $70, $6A, $6A db $A8, $AC, $B3, $B4, $B5, $BA, $B7, $B3 db $B0, $AC, $A6, $A0, $8A, $74, $6D, $6D db $AD, $B2, $B6, $B7, $B8, $BC, $BA, $B4 db $B3, $B1, $AC, $A7, $96, $84, $74, $74 db $B1, $B5, $B9, $BA, $BA, $BE, $BC, $B6 db $B4, $B2, $AE, $AB, $9E, $91, $83, $83 db $B4, $B7, $BB, $BC, $BD, $C0, $BE, $BC db $B8, $B4, $B0, $AC, $A3, $9A, $90, $90 db $B8, $BB, $C0, $C1, $C2, $C3, $C2, $BF db $B9, $B5, $B1, $AE, $A6, $9E, $92, $92 db $BA, $BE, $C4, $C5, $C6, $C8, $C4, $C0 db $BC, $B8, $B5, $B1, $AB, $A5, $9C, $9C db $BC, $C0, $C4, $C7, $C9, $CA, $C7, $C5 db $C1, $BE, $BD, $B8, $B4, $AB, $A2, $A2 db $BE, $C1, $C7, $C9, $CC, $CA, $CA, $C9 db $C5, $C1, $C0, $BE, $B8, $B1, $A7, $A7 db $C3, $C5, $C8, $CA, $CC, $CC, $CD, $CB db $C9, $C6, $C5, $C4, $BC, $B4, $AA, $AA db $C8, $C8, $CC, $CE, $D0, $CF, $CF, $CE db $CE, $CE, $CB, $C7, $BD, $B4, $AC, $AC db $C7, $C7, $CB, $CD, $CE, $D1, $D3, $D5 db $D4, $CF, $CC, $C9, $C0, $B6, $AE, $AE db $C5, $C5, $C8, $CB, $CD, $D0, $D2, $D4 db $D3, $CC, $C9, $C4, $BF, $B2, $B3, $B3 db $C3, $C3, $C5, $C9, $CC, $C8, $D7, $E6 db $D8, $D1, $CF, $C9, $C4, $B5, $AF, $AF ;back up map in case of fault? (? x 12) LUT_9120: db $00, $00 fill 15, $ff db $10, $16, $18, $18, $18, $18, $18, $00 db $00, $00, $00 db $07, $1A, $1B, $16, $16, $16, $16, $16 db $00, $00, $00 db $10, $12, $1B, $16, $16, $14, $16, $13 db $13, $00, $00, $00 db $18, $1A, $1D, $16, $12, $12, $12, $12 db $12, $00, $00 db $10, $1A, $1D, $1A, $16, $12, $12, $12 db $12, $12, $00, $00 db $1A, $1A, $1D db $18, $16, $12, $12, $12, $12, $12, $00, $05, $26 db $21, $1B, $18, $14, $12, $12, $10, $12, $12, $00 db $10, $24, $20, $1A, $16, $12, $12, $12, $10, $10 db $10, $00, $18, $23, $1F, $1A, $16, $12, $12, $12 db $10, $10, $10, $00, $1A, $21, $1B, $18, $14, $12 db $12, $12, $10, $10, $10, $00, $19, $20, $18, $16 db $12, $10, $10, $12, $10, $10, $10, $00, $18, $18 db $16, $16, $12, $10, $10, $10, $10, $10, $10, $00 db $0A, $10, $12, $10, $12, $10, $10, $10, $0D, $0A db $09, $00, $00, $00, $00, $00, $00, $00, $00, $00 db $00, $00, $00, ;Unknown 8x10 Look up Table ????? LUT_91D4: db $60, $41, $32, $25, $22, $1B, $1E, $20 db $98, $71, $5B, $3E, $32, $28, $23, $2B db $B6, $A0, $8D, $64, $50, $38, $2F, $2D db $C1, $B6, $AA, $89, $70, $50, $40, $3A db $C6, $C0, $B9, $A4, $8E, $6C, $57, $4B db $CB, $C8, $C5, $BE, $B4, $9C, $88, $79 db $CC, $CB, $C9, $C6, $C1, $B4, $A8, $9C db $CD, $CC, $CC, $CB, $CA, $C7, $C4, $C1 db $CD, $CD, $CD, $CC, $CB, $CA, $C9, $C7 db $CD, $CD, $CD, $CD, $CC, $CB, $CA, $C8 ;Unknown LUT_9224: db $6C, $6C, $50, $36, $1B, $0E, $0C, $0C ;Unknown LUT_922C: db $40, $4A, $53, $53, $53, $4F, $4A, $45 db $40, $40, $40, $40, $40 ;Unknown LUT_9239: db $23, $23, $23, $23, $23, $26, $28, $2B db $2E, $31, $33, $36, $39, $3B ;Unknown LUT_9247: db $A2, $AF, $BD, $BD, $BF, $BF, $B7, $B2 db $AA, $00, $00, $00, $00, $00 ; ;Unknown LUT_9255: db $0A, $16, $1F, $26, $2D, $33, $38, $3C db $40, $00, $00, $00, $00, $00, ;TPS v WTS Table1a LUT_9263: db $12, $0F, $0C, $08, $06, $05, $00, $00 ;TPS v WTS Table1b LUT_926B: db $16, $11, $0C, $09, $07, $05, $00, $00 ;Unknown LUT_9273: db $53, $3B, $1C, $15, $0D, $04, $00, $00 ;Unknown LUT_927B: db $53, $4F, $2D, $15, $0D, $04, $00, $00 ;Unknown LUT_9283: db $53, $4F, $2D, $20, $18, $11, $08, $00 ;Unknown LUT_928B: db $8D, $73, $49, $37, $20, $18, $13, $13 ;Unknown LUT_9293: db $A6, $A6, $4D, $33, $29, $1D, $13, $13 ;Unknown LUT_929B: db $9A, $92, $8E, $8C, $8A, $88, $86, $85 db $83, $82, $80, $7E, $7B, $78, $72 ;Fuelling? V RPM LUT_92AA: db $26, $26, $2B, $2B, $2B, $2B, $2E, $31 db $33, $36, $39, $41, $46, $46 ;Unknown LUT_92B8: db $82, $81, $6C, $3B, $26, $1A, $13, $10 ;Unknown LUT_92C0: db $82, $82, $82, $7F, $52, $38, $29, $1F ;Unknown LUT_92CA: db $BA, $BA, $BA, $A3, $8F, $82, $82, $82 ;Unknown LUT_92D0: db $FD, $FD, $FD, $FE, $FE db $FC, $FA, $FA, $FA, $FA ;Unknown LUT_92DA: db $FD, $FD, $FB, $FB, $FB db $FB, $FA, $FA, $FA, $FA ;Unknown LUT_92E4: db $FD, $FD, $FD, $FE, $FE db $FF, $FF, $FF, $FE, $FE ;Unknown LUT_92EE: db $7E, $7E, $7E, $70, $52 db $3C, $2E, $18, $18, $19 ;Unknown LUT_92F8: db $7E, $7E, $7E, $70, $52 db $3C, $2E, $20, ;Unknown LUT_9300: db $BD, $BD, $BD, $BD, $A4, $78, $5C, $32 ;Unknown LUT_9308: db $E4, $E4, $E4, $E4, $E4, $AC, $5C, $32 ;Unknown LUT_9310: db $80, $80, $80, $93, $A6, $BA, $CD, $E0 db $F3, $F3, $F3, $F3, $F3, $F3 ;Unknown LUT_931E: db $F3, $E0, $C9, $A0, $8C, $84, $80, $80 ;Unknown LUT_9326: db $F3, $E6, $CA, $A0, $80, $5A, $33, $20 ;Unknown LUT_932E: db $A2, $5A, $5A, $5A, $5A, $2D, $00, $00 db $19, $14, $0A, $08, $06, $06, $06, $06 ;Unknown LUT_933E: db $AD, $93, $80, $80, $80, $80, $80, $80 ;Unknown LUT_9346: db $FF, $93, $57, $3C, $2B, $20, $19, $12 ;Unknown LUT_934E: db $14, $10, $00, $00, $00, $00 ;Unknown LUT_9354: db $30, $30, $2A, $23, $1D, $16, $10, $10 db $66, $32 db $08, $07, $03, $01, $01, $01, $02, $02 ;Unknown - Ignition related (degs to time?) LUT_9366: db $4A, $4A, $4A, $4A, $4A db $43, $3B, $36, $30 ;Unknown LUT_936F: db $3A, $44, $48, $55, $5F, $66 db $6B, $70, $74, $7C, $84, $8E, $98, $A2 ;Unknown LUT_937D: db $04, $04, $05, $05, $06, $06, $06, $07 db $08, $08, $09, $09, $09, $0A, $00, $00 db $00, $00, $00 ; ;Base Ignition ---- 13 x 16 LUT LUT_9390: db $18, $18, $18, $2F, $4E, $57, $6F, $7B db $89, $84, $7A, $77, $78, $78, $78, $79 db $18, $18, $18, $2F, $4E, $57, $69, $7B db $89, $84, $7A, $77, $78, $78, $78, $79 db $18, $18, $18, $2F, $54, $68, $77, $83 db $8C, $87, $83, $83, $84, $84, $84, $85 db $18, $18, $18, $2F, $54, $68, $77, $83 db $8C, $8D, $8B, $8B, $89, $89, $89, $8A db $23, $23, $2E, $3A, $57, $5F, $6F, $7B db $86, $8D, $88, $85, $86, $86, $86, $87 db $2E, $2E, $42, $4B, $51, $5A, $60, $70 db $7B, $7C, $80, $7D, $79, $79, $79, $7A db $39, $39, $39, $46, $4E, $57, $58, $64 db $6D, $6E, $77, $6F, $6D, $6D, $6D, $6E db $2E, $2E, $2E, $40, $49, $51, $55, $5F db $61, $65, $6F, $6C, $6D, $6D, $6D, $6E db $23, $23, $23, $35, $3A, $49, $50, $59 db $5F, $62, $6C, $69, $68, $68, $68, $69 db $1D, $1D, $1D, $24, $29, $38, $4A, $50 db $56, $57, $64, $64, $65, $65, $65, $66 db $18, $18, $18, $1B, $1B, $2C, $3B, $3F db $45, $46, $55, $5E, $59, $59, $59, $5A db $18, $18, $18, $19, $19, $1E, $2D, $34 db $45, $46, $4F, $5B, $59, $59, $59, $5A db $18, $18, $18, $19, $19, $1E, $22, $26 db $3F, $46, $4F, $5B, $59, $59, $59, $5A ;Unknown or 9DC0 LUT_9460: db $00, $00, $00, $00, $00, $00, $00, $00 db $05, $0B, $0B, $00, $00, $02, $08, $0B ;Unknown LUT_9470: db $0B, $00, $00, $05, $08, $05, $0B, $00 db $00, $02, $05, $05, $08, $00, $00, $00 db $00, $00, $00, $00 ;WTS v Ignition Advance LUT_9484: db $91, $8B, $80, $80, $80, $80, $80, $80 db $80, $75 ;Ignition Dwell Time LUT_948E: db $60, $5B, $48, $3F, $37, $31, $2D, $28, $25 ;Unknown LUT_9497: db $00, $00, $00, $37, $6E, $A0, $A0, $A0, $A0 ;Unknown LUT_94A0: db $00 db $2C, $30, $2E, $2E, $2C, $2A, $2D, $2B, $32, $4C db $72, $F6, $FF, $FF, $FF, $FF ;Unknown LUT_94B1: db $FF, $FF, $DA, $AF, $93, $80, $71, $66 ;Unknown LUT_94B9: db $1E, $36, $60, $78, $3C, $50 db $64, $78, ;Unknown LUT_94C1: db $1E, $36, $4C, $64, $3C, $50, $64, $78 ;Unknown LUT_94C9: db $3C, $3C, $1E, $00, $00, $00, $00, $00 ;Unknown LUT_94D1: db $34, $40, $23, $26, $33 ;Unknown ?? LUT_94D6: db $40, $5A db $60, $D0, $DA, $8A, $90 db $2D, $30, $2A, $2B, $3D, $40, $5D db $60, $3D, $40, db $8D, $90, $3D, $40, $7D, $80, $60, $80, $5A, $63 db $51, $56, $5C, $61, $81, $87, $81, $87, $FF, $FF db $AF, $B3, $63, $68, $CF, $D1, $C0, $C3, $D0, $D6 db $C3, $CA, $9D, $A1, $D9, $DA, $E7, $E8, $B8, $BB db $8F, $94, $A5, $A9, $DC, $DF, $C7, $CA, $DA, $DA db $FF, $FF, $81, $85, $0E, $0F, $0B, $0C, $8B, $8F db $03, $0D, $75, $7F, $B2, $BB, $94, $9E, $15, $16 db $1C, $1D, $1C, $20, $DC, $DE, $00, $86, $D9, $DA db $0E, $0F, $0B, $0C, $36, $3A, $4A, $4D, $4B, $4E db $90, $93, $5A, $60, $8B, $90, $89, $8F, $25, $26 db $AF, $B3, $FF, $FF, $4A, $4D, $87, $8A, $FF, $FF db $2A, $30 ;Unknown LUT_9557: db $31, $31, $25, $40, $2E, $40, $48, $40 db $25, $40, $2E, $40, $4D, $40, $25, $40, $2E, $38 db $4D, $18, $31, $31, $25, $20, $2E, $20, $48, $20 db $25, $20, $2E, $20, $4D, $20, $25, $20, $2E, $20 db $4D, $18 ;Unknown LUT_957F: db $31, $31, $25, $60, $43, $30, $48, $46 db $25, $60, $49, $26, $43, $30, $25, $60, $5A, $1D db $27, $07, $31, $31, $25, $60, $2E, $60, $48, $46 db $25, $60, $2A, $30, $43, $30, $25, $60, $42, $33 db $5D, $20, $31, $31, $25, $30, $2E, $30, $48, $30 db $25, $30, $2E, $30, $4D, $30, $25, $30, $2E, $30 db $4D, $18 ;Unknown LUT_95BB: db $31, $31, $10, $3D, $37, $22, $7E, $6F db $66, $37, $10, $10, $20, $18, $30, $18, $18, $18 db $20, $18, $50, $18, $18, $18, $1C, $18, $34, $18 db $3C, $18 ;Unknown LUT_95D9: db $00, $00, $00, $20, $30, $40, $50, $60 db $70, $80 ;Unknown LUT_95E3: db $00, $00, $00, $00, $00, $00, $00, $60 db $70, $80 ;Unknown ?? check tables thru to 9600 for errors!!!! LUT_95ED: db $00, $02, $03, $01 ;Target Idle v WTS LUT_95F1: db $E6, $E6, $E6, $CD, $B3, $9A, $80, $66 db $FF, $FF, $FF, $FF, $FF, $FF, $FF ;Unknown 13x8 16-bit LUT???? LUT_9600: db $00, $00, $00, $00, $00, $00, $00, $00 db $00, $00, $00, $00, $00, $00, $00, $00 db $00, $00, $00, $02, $02, $02, $02, $02 db $00, $00, $00, $00, $00, $00, $00, $00 db $00, $00, $02, $02, $02, $02, $03, $03 db $06, $06, $00, $00, $00, $00, $00, $00 db $00, $02, $02, $02, $02, $03, $03, $06 db $09, $00, $00, $00, $00, $00, $00, $00 db $00, $02, $02, $02, $02, $03, $04, $08 db $0C, $00, $00, $00, $00, $00, $00, $00 db $00, $02, $02, $02, $02, $03, $05, $0A db $0E, $00, $00, $00, $00, $00, $00, $00 db $00, $02, $02, $02, $02, $04, $06, $0D db $10, $00, $00, $00, $00, $00, $00 ;Unknown LUT_966F: db $00, $00, $03, $03, $03, $03, $06, $09 db $0F, $12, $00, $00, $00, $00, $00, $00 db $00, $00, $03, $03, $04, $05, $07, $0D db $11, $14, $00, $00, $00, $00, $00, $00 db $00, $00, $04, $04, $05, $07, $08, $0F db $14, $17, $00, $00, $00, $00, $00, $00 db $00, $00, $04, $04, $06, $08, $0A, $11 db $18, $1A, $00, $00, $00, $00, $00, $00 db $00, $00, $00, $00, $08, $0A, $0D, $14 db $1E, $1E, $00, $00, $00, $00, $00, $00 db $00, $00, $00, $00, $00, $0D, $10, $19 db $1E, $1E, $00, $00, $00, $00, $00, $00 db $00, $00, $00, $00, $00, $0F, $14, $19 db $1E, $1E, $00, $00, $00, $00, $00, $00 db $00, $00, $00, $00, $00, $0F, $14, $19 db $1E, $1E, $00, $00, $00, $00, $00, $00 db $00, $00, $00, $00, $00, $0F, $14, $19 db $1E, $1E, $00, $00, $00, $00, $00, $00 ;Unknown LUT_9700: db $12, $13, $14, $15, $21, $22, $23, $24 db $25, $31, $32, $41, $42 db $44, $45, $51, $53, $81, $82, $83, $84, $00, $00 db $00, $00, ;Diagnostics LUT (16-bit addresses) DIAG_LUT: db $00, $44, $00, $46, $00, $45, $00, $47 db $01, $87, $00, $4D, $00, $4E, $00, $D5 db $00, $93, $00, $DF, $00, $E0, $98, $03 db $00, $70, $00, $5B, $00, $5A, $00, $AF db $00, $FE, $00, $FF, $00, $66, $00, $40 db $00, $BA, $00, $D8, $00, $F3, $00, $EB db $00, $E1, $00, $D9, $00, $58, $01, $88 db $01, $86, $00, $95, $00, $79, $00, $02 db $01, $73, $01, $74, $01, $77, $01, $78 db $01, $79, $01, $7A ;Unknown - Called from TX 18 routine LUT_9765: db $01, $6F db $01, $73 ;Unknown - called from TXf 19 routine LUT_9769: db $01, $6F, $01, $73, $01, $7B ;Unknown LUT_976F: db $00, $00 db $00, $08, $00, $00, $08, $08, $05, $05, $05, ;Unknown LUT_977A: db $05, $08, $08 ;Unknown – RX Encryption Data??? LUT_977D: db $00, $00, $FD, $7D, $FB, $7B, $F7, $77 db $EF, $6F, $DF, $5F, $80, $00, $00, $00, $01, $01 db $01, $00, $05, $04, $0D, $0C, $1D, $1C, $80, $00 db $19, $80, $18, $80, $13, $80, $19, $81, $18, $80 db $18, $81, $18, $80, $19, ;Unknown LUT_97A8: db $82 ;Unknown LUT_97A9: db $81, $1C, $02, $00 db $01, $04, $04, $02, $FF, ;related to timing LUT_97B2: db $1A, $02, $00, $01, $04 db $04, $02, $14, $F8, $01, $16, $06, $02, $FF, $14 db $02, $00, $01, $02, $02, $02, $06, $0A, $03, $FF db $18, $00, $00, $01, $06, $06, $02, $FF, $18, $00 db $00, $02, $FF, $14, $00, $00, $01, $04, $04, $02 db $08, $10, $03, $FF ;WTS linearisation table LUT_97E3: db $0F, $2D, $3D, $47, $4F, $57 db $5E, $64, $6C, $73, $7C, $84, $91, $A0, $B7, $FF ;IAT linearization table LUT_97F3: db $06, $2A, $3B, $46, $4F, $57, $5F, $66, $6D, $75 db $7E, $87, $93, $A3, $BF, $F2, $EB, $FF, $FF, $FF db $FF, $FF, $FF, $FF, $FF, $FF, $FF, $00, $05, ; if 9810 is 00 then config resistors are used to get offset from L9811 ; else the value in L9810 is the offset (-1) for table at L9819 LUT_9810: db $00 ; 9811 or 9819 contain config data for HWCR (L00D7) LUT_9811: db $20, $22, $0A, $12, $21, $23, $0B, $13 ; 9819 could be for software test only – note same data different order! LUT_9819: db $0A, $0B, $12, $13, $22, $23, $20, $21 LUT_9821: db $01, $03, $28, $08 db $50, $A0, $00, $88, $06, $00, $0D, $06 db $E0, $33 db $64 ;limits for VE test at LCE72 LUT_9830 db $5D, $74, LUT_9832 db $50, $78, $0D, $04, $72 db $FF, $D3 db $50, $28, $50 ;Unknown significant config byte? LUT_983C: db $2E ;Unknown config byte LUT_983D: db $3D db $29 ;VE test limit at LCEAD LUT_983F: db $0D ;Unknown config byte LUT_9840: db $14 db $3C ;Unknown config byte LUT_9842: db $36 db $02, $94, $02, $11, $7C, $04, $05, $20 ;Unknown config bytes LUT_984B: db $20 db $06 db $78 ;Unknown config byte LUT_984E: db $3C db $C8, $78, $03, $13, $4F, $46, $01, $3C db $3C, $58, $C8, $10, $17, $0C, $A2, $11, $1E, ;Fuel trim value increments FT_INC: db $01, $04, $04, $02, $04 ;Unknown LUT_9865: db $61, $A8, ; Fuel trim limits FT_LIM: db $5A, $A6 ; (-0x59 to +0x5A) ;Unknown LUT_9869: db $C8, $64, $05 ;Unknown config byte LUT_986C: db $3D db $28 db $0A ;Unknown config byte LUT_986F: db $80 db $20, $7A, $86 ;config byte?? – log!! LUT_9873 db $71 db $93 db $77, $89, $86, $3D, $FF, $80, $03, $06, $06, $03 db $DA, $7B, $44, $D0, $4C, $3C, $2B, $01, $F3, $00 db $CC, $9F, $7C, $13, $0A, $A0, $77, $04, $03, $73 db $3C, $1C, $03, $03, $8F, $03, $F0, $C0, $28, $09 db $09, $12, $1E, $22, $32, $0B, $40, $14, $02, $04 db $81, $02, $B8, $02, $A0, $03, $48, $78, $4C, $10 db $72 LUT_98B2: db $1E, $E1, $39, $2D, $FF, $0F ;Unknown – config byte LUT_98B8: db $02 db $53, $5E db $D6, $30 ; TPS lower limit LUT_98BD db $0C LUT_98BE db $20, $3D, $5D, $56, $78, $94, $3D db $48, $7A, $0A, $08, $32, $01, $50, ;Unknown config bytes LUT_98CC: db $CD, $28, $30, $6D ;Unknown config byte LUT_98D0: db $14 db $04, $05, $0B, $7C, $D8, $1D, ;Unknown config byte LUT_98D7: db $39 db $78 db $B3, $5A, $0E, $20, $CA ;VE test limit at LD92A LUT_98DE db $73 LUT_98DF db $75, $0A, $90, $72 ;VE test limit at LD9F9 LUT_98E3 db $FF LUT_98E4 db $28, $10, $04, $18, $1E, L98E9 db $D9, $58, $08, $50 db $30, $50, $8C, $05, $04, $14, $28, $0D, $02, $05 db $50, $78, $28, $64, $3C, ;target idle default values (RPM/8?) LUT_98FC db $66, $80, $7A ;816rpm, 1024rpm, 976rpm ??? LUT_98FF db $96, $0A db $21, $00, $09, $00, $32, $64, $03, $3C, $09, $1D db $03, $C8, $85, $8F, $08, $40, $C8, $4E, $96, $32 db $64, $C8, $5C, $43, $73, $66, $43, $6A, $D8, $EB db $72, $6F, $8C, $2E, $3A, $75, $8F, $FF, $1E, $03 ; db $53, $58, $50, $C0, $01, $03, $28, $3C, $3C, $28 db $08, $00, $78, $0A, $66, ;9938 fetched at LC235 – I2C/immob LUT_9938: db $78, $8C, $96, $78, $03 db $0A, $1E, $FF, $FF, $FF, $FF, $FF, $FF, $FF, $FF fill 697, $FF ;9C00 Fuel Map 2 – 16 x 16 F_MAP2 db $A0, $A0, $A0, $A2, $A3, $A3, $9E, $90 db $8A, $8A, $85, $80, $7A, $6A, $65, $65 db $A4, $A6, $A6, $AB, $AD, $AE, $AB, $A2 db $9A, $95, $90, $82, $80, $6C, $67, $67 db $A6, $AA, $B0, $B5, $B8, $B9, $B3, $AD db $AA, $A4, $9D, $8B, $85, $70, $6A, $6A db $A8, $A7, $AD, $B8, $BB, $BA, $B4, $AF db $AC, $A7, $A1, $98, $8A, $74, $6D, $6D db $AD, $B1, $B9, $BD, $BF, $BF, $BB, $B4 db $B1, $AA, $A3, $9A, $96, $84, $74, $74 db $B1, $B2, $BA, $BD, $C0, $BE, $BC, $B6 db $B3, $AF, $A9, $A0, $9E, $91, $83, $83 db $B4, $B4, $BB, $C0, $C0, $C0, $BD, $B9, $B5, $B1, $AB, $A4, $A3, $9A db $90, $90, $B8, $BB, $C0, $C1, $C4, $C5, $C2, $BC db $BA, $B8, $B1, $AA, $A6, $9E, $92, $92, $BA, $BE db $C2, $C5, $C8, $C8, $C6, $C2, $C0, $BC, $B8, $B0 db $AB, $A5, $9C, $9C, $BC, $C0, $C4, $C6, $C9, $CE db $CC, $C7, $C8, $C4, $BE, $B7, $B4, $AB, $A2, $A2 db $BE, $C1, $C5, $C7, $C9, $D3, $D1, $D2, $D1, $D0 db $C9, $C1, $B8, $B1, $A7, $A7, $C3, $C5, $C6, $CA db $CC, $D2, $D3, $D5, $D5, $D4, $CD, $C4, $BC, $B4 db $AA, $AA, $C8, $C8, $C9, $CC, $CD, $D5, $D5, $D8 db $D7, $D4, $CF, $C7, $BD, $B4, $AC, $AC, $C7, $C7 db $C9, $CD, $CE, $D7, $D8, $DA, $DB, $D7, $D2, $CB db $C0, $B6, $AE, $AE, $C5, $C5, $CB, $CE, $CF, $D8 db $DB, $DD, $E0, $DB, $D5, $CD, $BF, $B2, $B3, $B3 db $C3, $C3, $C2, $C5, $C6, $CD, $DC, $E3, $E3, $DC db $D7, $CF, $C4, $B5, $AF, $AF ; ;Unknown table – alternative to 9120 (? x 12) LUT_9D00: db $00, $00, $00, $00 fill 28, $00 db $09, $06, $00, $00, $00, $00, $00, $00, $00, $00 db $00, $00, $06, $09, $00, $00, $00, $00, $00, $00 db $00, $00, $00, $01, $09, $0F, $00, $00, $00, $00 db $00, $00, $00, $00, $00, $01, $09, $0F, $00, $00 db $00, $00, $00, $00, $00, $00, $03, $06, $0B, $0C db $00, $00, $00, $00, $00, $00, $03, $00, $04, $05 db $0A, $0D, $00, $00, $00, $00, $00, $00, $05, $03 db $06, $0B, $0D, $0E, $00, $00, $00, $00, $03, $03 db $04, $09, $06, $0C, $11, $0E, $00, $00, $00, $00 db $01, $01, $04, $0A, $06, $0A, $0F, $0F, $00, $00 db $00, $00, $00, $00, $08, $07, $0A, $0C, $11, $12 db $00, $00, $00, $00, $00, $00, $00, $0A, $0A, $0F db $11, $0B, $00, $00, $00, $00, $00, $00, $00, $08 db $09, $0C, $0D, $0B, $00, $00, $00, $00, $00, $00 db $00, $08, $09, $09, $0F, $0B, $00, $00, $00, $00 db $00, $00, $00, $05, $07, $08, $09, $06, $00, $00 ;Unknown or 9460 db $00, $00, $00, $00, $00, $00, $00, $00, $05, $0B db $00, $00, $00, $02, $08, $0B, $00, $00, $00, $05 ; db $08, $05, $00, $00, $00, $02, $05, $05, $00, $00 db $00, $00, $00, $00, $00, $00, $FF, $FF, $FF, $FF ; fill 8728, $FF ; ; ; ; Programme Code Starts Here ; ; START: ldS #$043F ;stack is at 043F callr SUBR1 ;initialization (calls immob) oim L0083, bit6 ;set bit 6, L0083 MAIN: lds ;load stack pointer #043F call SUBR2 call SUBR3 call SUBR4 brclr HWCR, #$02, LC01E ; if bit 1, L00D7 = 0, jmp to C01E call SUBR5 ; calls I2C read/write ??? call SUBR6 LC01E: call SUBR7 call SUBR8 call SUBR9 ;fuelling calcs call SUBR10 ;ignition timing calcs call SUBR11 call SUBR12 call SUBR13 call SUBR14 aim ;clear bit 6 L83 = main loop done at least once nop nop nop jmp MAIN ; ; SUBR1: ldD #$0210 stD PORT1 ; Port1, Port2 ldaA #$40 staA P1DDR ;Port1 DDR clrA staA PORT3 ;port3? staA PORT4 ;port4? ldaA #$42 staA PORT5 ;Port5 ? ldaA #$04 staA PORT6 ;Port6 Fuel Pump ON? clrA staA P7DDR ;clear 7 ddr?? staA P7DDR ;clear PORT 7?? ldD #$1219 staA T1CSR ; T1CSR - enable input capture on T1 (CAS?????) staB T2CSR ; T2CSR - ldD #$5E0A stD T3CSR0 ; T3CSR? ldD TMR1H ;timer1 addD #$000A ;add 10 to timer 1 stD T2OCR ;store in output compare reg call LC501 ;SUBR1_1 (only if eng not running) call LC51C ;SUBR1_2 aim ;clear bit 0 L43 ; ;Clear down stored variables or retain based on ;RAM control flag and 41,42 (checksum??) ; brclr LC080 ;if RAM OK don’t do next ldD L0041 ;AB = 41,42 comA ;1s comp A cBA ;A-B beq LC0B6 ;bra if A=B ; ;fill RAM from L0282 to L02A2 with $80 ldD #$0080 ldY #$0202 LC087: stD 128, Y cmpY #$0222, Y++ LC08D bls LC087 ldaA L98CC ;A = $CD ldD #$9740 ;AB = $9740 ldaA L98D7 ;A = $39 tAB ;D = $3939 comB ;1’s complement B stD L0041 ;42,42=TPS,TPS?? clrA ;Clear fault code registers staA L0044 ;44 = $00 staA L0045 ;45 = $00 staA L0046 ;46 = $00 staA L0047 ;47 = $00 staA L0048 ;48 = $00 ldaB #$80 staB L004A ;4A = $80 staA L0049 ;4A = $80 ldaA L98B8 ;A = $02 staA L0200 ;200 = $02 ldaA #$01 staA L0043 ;43 = #$01 oim ;set bits 7,6 L00C1 ; ;clear RAM from $004B to $0109 ldy #004B ; Y = #$004B clrA ;A = 0 clrB ;B=0 stD Y cmpY #0109 ;compare Y with #0109 Y++ LC0C5: bcs LC0BF ;bra if less than ; ;set L00D2 bit7 if R331 is present ;if it isn’t L0010 = $05 ; aim L00D2 ;clr bit 7 L00D2 brclr PORT4 ;if R331 present jmp LC0D1 oim L00D2 ;else set bit 7 L00D2 brclr L00D2,bit7,LC0D9 ldaA #$05 staA RMCR ;L0010 = #$05 if R331 not present ; ;get all analogue inputs LC0D9: ldy #$0054 ;54 = start of analog registers LC0DD: ldaA #$00 ;00 = A/D ch0 ; ;Loop through all 8 channels of A/D converter ; LC0DF: pushA ;save channel number on stack call LE5FF ;call A/D routine staA Y ;save result in (54+channel) popA ;retrieve channel number incA ;point to next channel cmpA #$07 ; 8 channels available bls LC0DF ;if all 8 not read loop ldaA L005A ;get O2 sensor reading lslA ;5A > 80? bcc LC0F2 ;if msb = 0 do nothing ldaA #$FF ;if msb=1 set all bits LC0F2 staA L005A ;O2 sensor value = L005A*2 or FF ;A/D done ; ldX #$0202 ; LC0F7: ldD 0, X ;D=L0202 tstA beq LC108 mul lslD addD #$0080 ; ;************ disassembly goes awry here! ; UK_C101: db CD, FE, 98, 73, BD, E5, A0 ;;;;;;;;/* ; LC108: ldaB #$80 stD 0, X incX incX cmpX #$0222 bls LC0F7 ;loop back aim L0047,#$FB ;clear L0047 bit2 aim L0046 ;clear L0046 bit6,2 ldx 0100 ; X = 100 clrA ;A = 0 ; ;Load all default Manifold Pressure values ldaB L0059 ; L0059 = Manifold Pressure lslD lslD ;L0059 * 4 stD L0064 ;L0064 = L0059 * 4 ldaA L0059 ; Get MAP_Raw tAB ;A, B = MAP stD L0066 ;66,67 = MAP stD L0068 ;68,69 = MAP staA L006A ;6A = MAP staA 24, X ;124 = MAP ldaB #$B4 ;B = 180 mul ;MAP*180 stD L005E ;5E,5F = MAP*180 stD L0060 ;60,61 = MAP*180 stD L0062 ;62,63 = MAP*180 ;Load all default TPS values ldaA L005B ;Get TPS Volts subA L0041 ;subtract L0041 (TPS_Base?) bcs LC142 ;TPS Volts 0 in L7C ldaA #$01 staA L0081 ;L0081 = 1 staA L00B7 ;L00B7 = 1 ldaA PORT1 ;PORT1 andA #%10000000 ;isolate bit 7 oraA #%00000001 ;set bit 0 staA L0085 ;store in L0085 ;initialize more stuff ldaA #$06 ; staA L0086 ;L0086 = $06 staA L0087 ;L0087 = $06 ldaA L98CD staA L0088 ;L0088 = $28 ldaA L98D0 staA L0089 ;L0089 = $14 oim L008E, #$04 ;set bit 2 L008E oim L00AF, #$A0 ;set bits 7 & 5 L00AF ;ignition timing, A0h = 5degs oim L00B0, #$A0 ;set bits 7 & 5 L00B0 ldaA L948E staA IgnDwel ;L00B1 = $60 oim L00B4, #$06 ;set bits 3 & 1 LB4 ldaA L9928 staA L00E3 ;L00E3 = $03 ldaA L9912 ;A = $4E brclr HWCR, #$20, LC1A8 ;bra if L00D7 bit5 clr ldaA L9927 LC1A8: staA L00E2 ;L00E2 = $1E call LC50C ldaA #$FF staA L0096 ;L0096 = $FF staA L009A ;L009A = $FF staA 25, X ;125???? staA L0165 ;L0165 = $FF staA L0167 ;L0167 = $FF staA L00FB ;L00FB = $FF staA 37, X staA 65, X ldaA #$80 staA L00E8 ;L00E8 = $80 staA L00E9 ;L00E9 = $80 staA STFT ;STFT = $80 ;STFT = 0 staA L018A ;L018A = $80 ldaA L993C staA L018E ;L018E = $03 ldaA #$64 staA L00FF ;L00FF = $64 ;initial Inj PWL staA 1, X ldD #$1388 stD L00BC ;L00BC = $1388 oim L0077, #$40 ;L0077 bit6 = 1 inc 23, X brclr L0022, #%00010100, LC1F9 bls LC238 ldaA L98D8 staA 38, X ldaA L982F staA 69, X ldaA L98C2 staA 62, X brclr L004C, #%00110010, LC20E tstA popA brclr L003F, #%01111000, LC280 aim L002C, #$8F ;clear bits6,5,4 L002C sbcB L0080 ;B - L0080 - Carry oim L00BD, #$F3 ;L00BD bit7-1 = 1 andb inx ;X = 200???? ldaA ICR1H LC20E ei ret ;SUBR IMM1 – get immob codes from SEEPROM IMM1: ldaA #$78 ; staA L013A ;load 013A with #78 brclr LC22C ;test bit 7 L43 bclr LC22C? clr L013A ;clr 013A brset LC227 ;test bit6 L0043 brset LC227 brset LC227 ;test bit4 L0043 brset LC227 oim L004A #$80 ;set bit7 L004A oim L0043 #$40 ;set bit6 L0043 LC22A: bra LC22F ;jump to LC22F aim ;clear bit6 L0043 oim ;set bit6 L0043 aim ;clear bit5 L0043 LC235: ldaA L9938 ;Load A with L9938 (#78) staA L0139 ;Load L0139 with #78 brset ;test bit6 L0043 brset LC245 LC23F: clr L0049 ;clear L0049 aim ;set L004A to #80 ldaA #$0C ;load A with #0C staA L013B ;Load L013B with #0C ldaA #$03 ; staA L0185 ;Try 3 times max. aim L00E6 #$DF ;clear bit 5 L00E6 LC252: ldX #$0183 ;Load IndX with 0183 ldD #$0202 ;Load A and B with 02 call LC2DD ;call I2C tstB ;data received beq LC268 ;if no error branch tst L0185 ;test L0185 (error code??) beq LC29D ;if failed 3 times jmp dec L0185 ;dec loop cntr bra LC252 ;repeat if bad LC268: ldaA #$03 staA L0185 ;Load L0185 with #03 ldD L0183 ;Load D with L0183 cpD #$5AA5 ;test if D = #5AA5 beq LC27D ;if yes jump LC27D oim L0048 #$08 ;if no set bit 3 in L48 clr L013A ;clear L013A bra LC2AD ;skip next bit ; LC27D: ldX #$016F ;Data Good - Load X with #016F ldD #$040C ;Load B with #04, A with #0C? call LC2DD ;call I2C tstB ;data received? beq LC293 ;bra if good tst L0185 beq LC29D dec L0185 bra LC27D LC293: ldaA #$03 staA L0185 call LC9E0 ;Call LC9E0 bra LC2A9 LC29D: oim L0048 #$02 ;failed – set bit 1 L48 brset LC2A9 LC2A4: clr L013A bra LC2AD brclr LC2B3 ;don’t set a flag oim L0043, #$20 ;set a flag!!! LC2B0: call LC2B5 di ret ; ; ; ;L0015 is PORT5 DDR ?? ;L0016 is PORT5 ?? ;set up I2C for RX or TX pending. LC2B5: brclr L0043, bit5, LC2CA ;skip if L0043 bit5=0 brclr PORT5, bit1, LC2CA ;skip if Rx busy ldaA #$FC ;A = 11111100 staA P5DDR ;set up Port 5 DDR oim PORT5, #$02 ;set Port5 bit1 aim T3CSR0, #$FB ;clear bit2 counter?? oim L004B, #$80 ;set L004B bit7 LC2CA: oim L0043, #$20 ;set L0043 bit5 ret ; ; LC2CE: brclr LC2DC ;test for busy ldaA #$FE ;A = 11111110 staA P5DDR ;set up Port5 DDR aim L004B, #$7F ;clear bit7 4B aim L0043, #$DF ;clear bit5 ret ; ; ; ;I2C READ routine call with data in A (number of bytes in B), store data from X ;SDA is PORT5, bit6 ;SCK is PORT5, bit7 ;B is tested on return ; LC2DD: staB L00C1 ;logged, B=02h oim ;Start Bit SDA=1, SCK = 1 ldaB #$08 ;set up loop times 8 lslA ;left shift accA oraA #%00000001 ;set lsb to 1 (READ) call LC38F ;execute delay aim ;Clr SDA call LC38F ;execute delay call LC38F ; x2 aim ;clr SCK nop ;1 cycle delay nop ;x3 nop lslA ;send carry Bit bcc LC301 ;if no carry bra LC301 oim ;set SDA bra LC304 ;bra LC304 aim ;clr SDA decB ;decrement loop call LC38F ;execute delay oim ;set SCK call LC38F ;execute delay callr LC38F ;execute delay tstB ;test loop counter LOOP2: bne ; = ???????????????????? aim ;clr SCK call LC422 ;Call C422 (store code in L15?) cli ;disable interrupts callr LC38F ;execute delay callr LC38F ;execute delay oim ;SCK = 1 LC322: callr LC38F ;execute delay brset ;If no ACK jump to LC37F??? ; ;All good read data from EEPROM LC328: ldaB #$08 ;set up loop 8 times clrA callr LC38F ;execute delay LOOP1: aim ;clr SCK callr LC38F ;execute delay callr LC38F ;execute delay oim ;set SCK and bit 1? rorB ;rotate B right lslA ;left shift A brclr LB1 ;test SDA jump if clr oraA #%00000001 ;set bit 0 bra LC344 ;don’t clear bit andA #$FE ;clear bit 0 LB1: decB ;decrement counter tstB bne LOOP1 ;repeat if not got 8 bits aim ;clear SCK callr LC38F ;execute delay call LC417 ;store data?? aim ;clear SDA brclr LB2 ;If L00E6 bit 5=0, jmp C360 cmpA X ;compare A with X beq ;A=X jump to LC362 oim ;set bit 7 L00C1 bra ;jmp LC37F LB2: staA 0, X ;store data at X!!!!!!!!!!!!!!! ;contents of A on data bus on 4th cycle!!!!!! incX ;increment pointer ldaB #$08 ;B=8 dec >L00C1 ;L00C1 - 1 clrA ;A=0 oim ;set SCK call LC38F ;execute delay call LC38F ;execute delay test L00C1 beq LC382 sei aim ;clear SDA and bit 1 andB #$22 ;clear most of L22 cli bra LC330 ;send another byte? call LC417 ;set codes? LC382: oim ;set SDA callr LC38F ;execute delay callr LC38F ;execute delay aim ;clear SCK ldaB ;Load B with contents of L00C1 ret ; ;Delay Routine ;from 8D = 18.5uS (measures 17uS on LA??) xgDX ;3 cycles xgDX ;6 xgDX ;9 xgDX ;12 xgDX ;15 xgDX ;18 ret ;5 ; ; ;I2C Write Routine???? LC396: staB L00C1 oim PORT5, bit7,6 ;set bits7-6 in PORT5 ldaB #$08 lslA andA #%11111110 ;clear lsb for a write callr LC38F ;execute delay LC3A2 02 16 8D eorB ldaB tAB clr L0101 nop lslA bcc LC3B7 LC3B2 03 16 40 oim bra LC3BA LC3B7 02 16 BF aim PORT5 ;clear bit6 decB callr LC490 LC3BE 03 16 80 oim LC3C0: callr LC38F callr LC38F tstB bne LC3A9 di LC3C8 02 16 7F aim LC3CB BD C4 ?????? bhi LC3DD callr LC38F callr LC38F LC3D3 03 16 80 callr LC48F staB LC3DA brset PORT5, 40 17 brset LC3F3 callr LC38F LC3DE 02 16 7F aim L0016 = PORT5 LC3E1 A6 00 ldaA incX ldaB #$08 tst >L00C1 beq LC3FA dec >L00C1 call LC417 bra LC3AF LC3F3 8D 9A LC3F5 02 16 7F callr LC38F LC3FA: call LC417 LC3FD 02 16 BF LC400: callr LC38F LC402 03 16 80 LC405: callr LC38F callr LC38F LC409 03 16 40 callr LC38F call LC38F LC411 02 16 7F ldaB ret ; ; ; ;Setup L0015 (DDR for PORT5 bit 6 = SDA) ; LC417: pushA ;temp save A ldaA #$FE ;A = 11111110 brclr LC42B LC41E: ldaA #$FC ;A = 11111100 bra LC42B LC422: pushA ldaA #$BE ;A = 10111110 LC425 8F 4B 80 02 brclr LC42B ldaA #$BC ;A = 10111100 LC42B: staA P5DDR ;set up Port5 ddr popA ret ; ; ; SUBR2: clrA ;clear A (A=$00) LC430 brclr 85 01 49 brclr LC47D ;bra if clr location 85, bit 1, +$49 LC434 02 85 FE aim ;location 85 AND #FE ldX #$0122 ;load X with contents of L0122 ldaB #$1E ;load B 1E callr LC4AD ; call C4AD (;Unknown 30x loop) oraA #%00000001 ;OR acc A #$01 (A=$01) ldaB L0122 ;Load B contents of L0122 pushB ;push to stack bitB #%00000011 ;AccB AND 03 bne LC451 ;if not 0 skip to LC451 ;SE, no immob goes to C451 ldX #$0140 ;load X with contents of L0140 ldaB #$13 ;Load B with #$13 callr LC4AD ;call C4AD (;Unknown 19x loop) oraA #%00000010 ;acc A OR #$02 (A=$03) ;do this if L0122 is not zero LC451: popB ;retrieve B from stack tstB ;set flags bne LC463 ;if B is not 0 then bra LC463 ldX #$0153 ;LdX with #0153 ldaB #$04 ;Load B #$04 callr LC4AD ;call C4AD (;Unknown 4x loop) oraA #%00000100 ;acc A OR #$04 (A=$07) ldaB #$14 ;load B with #14 staB L0122 ;store #14 in L0122 LC463: ldaB L0123 ;load B with contents of L0123 bne LC47D ;if not zero bra C47D ldX #$0157 ;load X with #0157 ldaB #$05 ;load B #05 callr LC4AD ;call C4AD (;Unknown 5x loop) ldX #$00D9 ;Load X with time from start ldaB #$01 ;Load b with #01 callr LC4AD ;call C4AD (;Unknown 1x loop) oraA #%00001000 ;OR A (A=0F) ldaB #$50 ;Load B with #$50 staB L0123 ;Store B in L0123 LC47D: staA L0094 ;Store A (07) in 94 ldX #$0122 ; X is pointer to L0122 ldaA #$FF ;Load A with $FF brclr LC498 staA 30, X ; Time from start?? staA TfStart ; Time from start ldaB L006C ; Load B with $6C cmpB L9836 ; (acc B - $72) bcc LC498 ;skip next bit if B<$72 ldaB L9837 ;Load B with $FF staB 57, X ;Store B (FF) at X+57 brclr LC49E ;test something staA 2, X ;store A (FF or ?) in X+2 LC49E brclr PORT6 08 06 brclr LC4A8 ;test throttle opener? LC4A2 brclr L00DA 01 02 brclr LC4A8 ;test something else quit if clear staA 50, X ;otherwise store A (FF) in X+50 ret ; ; SUBR2_1: LC4A9: brclr L0094 01 0A ;brclr L0094, bit0 ; LC4AD: CF 00 FF 02 ;unknown opcode (bra?) -> L00FF = INJPWL??? dec 0, X LC4B3: inc X decB bne LC4AD LC4B7: rts ; ; dec 06,X ;decrement X+06, X-? incX ;increment X decB ;decrement loop counter) bne LC4AD ;repeat till loop done ret ; SUBR3: ldaA #$06 staA L0087 callr LC51C di LC4BF 02 08 13 LC4C2 03 08 10 LC4C5 02 18 39 LC4C8 03 18 18 oim dir LC4CB 02 19 5E aim dir LCBCE 03 19 42 oim,dir LC4D1 brclr L0081 01 02 callr LC501 LC4D7 brset L00B2 FF 09 brset LC4E4 LC4DB 03 19 0C oim,dir LC4DE 03 1A E0 oim,dir LC4E1: clrA staA L0099 ei brclr LC4EC LC4E9 03 D2 80 LC4EC brclr D2 80 06 brclr LC4F6 ldaA #$05 staA RMCR bra LC500 LC4F6: ldaA #$04 staA RMCR mul mul ldaA #$0A staA SCICR ; LC500: ret ; ; SUBR1_1: ; L009,A is Timer1 LC501: aim T2CSR, #$DF ;clr bit 5 T2 CSR LC504: ldD TMR1H ;Load D with contents of L9 addD #$000A ;Add $A stD OCR1H ;T1 output compare ret ; ;Initialise the CAS buffer?? ldy #$0224 ;L0224 LC510: ldD #$7FFF stD 128, Y++ ;L02A4, L02A5 = $7FFF stD 128, Y++ ;L02A6, L02A7 = $7FFF stD 128, Y++ ;L02A8, L02A9 = $7FFF stD 128, Y++ ;L02AA, L02AB = $7FFF ret ; SUBR1_2:ldD #$7E00 stD P1DDR ;Port1 DDR ldD #$0000 stD P3DDR ;Port3 DDR ldaA #$FE brclr L004B, bit1,LC52E LC52C: ldaA #$FC staA P5DDR ;Port5 DDR clrA staA P3CSR ;Port? DDR? LC533 02 32 BF LC536 02 35 BF LC539 02 1F EB aim L001F, $EB ;L001F clr bits4,2 LC53C 02 02 BF ;Port 1 clr bit 6 LC53F: ldaA #$10 staA L0024 ldD #$4E64 stD L0026 ;set up RTI ret ; ; this routine set HW Control reg (HWCR) L00D7 from resistor positions LC549: ldaB L9810 ;L9810 = $00 bne LC55C ldaB PORT4 ;get contents of PORT4 L0007 andB #%11100000 ;mask off lower bits lsrB ;right shift bits 7-5 lsrB ;to lsrB ;bits 2-0 lsrB ;remember carry! lsrB ;new value in B ldX #$9811 ;X = 9811 bra LC562 ; ;- software test mode? allows config to be using L9810 instead of resistors ; LC55C: decB andB #%00000111 ldX #$9819 LC562: aBX ;add B to X ldaB 0, X ;load B with 9811+X (9812=22) staB HWCR ;store B in L00D7 ret ; ; ****************************************************************************************** ; *************************** SUBR 4 ******************************************************* ; ****************************************************************************************** ; ; SUBR4: ldaA PORT3 ; get contents of Port3 xorA #%11000001 ; test for changes on Idle,?,? pushA ; save Port3 bits7,6,0 to stack xorA L0079 ; Status Flags 4 tAB andA L0078 comB andB L0079 ; Status Flags 4 aBA brset L0081, bit1,0 LC581 LC57A: ldaB L0124 addB #$50 bcc LC583 oraA #%00100000 LC583 brset L0081, 03 07 brset LC58E ;L0081 bits1,0 LC587: ldaB L0124 addB #$20 bcc LC590 andA #%11101111 LC590 02 D2 FE di ldaB L0127 bne LC5A5 ldX #$0000 ; clear actuator bytes stX L0163 ; actuator bytes 1,2 stX L016D ; actuator bytes n,n+1 ei bra LC5CA LC5A5: ldaB L0163 ; load actuator byte1 ei andA #%11111101 ; clearA bit1 oraA #%00000100 ; setA bit2 cmpB #$10 ; test (L0163) actuators bit4 beq LC5CA ; bit set branch oraA #%00000010 ; otherwise set bit 1 andA #%11111011 ; clear bit2 cmpB #$80 ; test (L0163) actuators bit7 beq LC5CA andA #%11111001 ; F9 cmpB #$C0 ; test (L0163) actuators bits 7,6 bne LC5CA brclr L00B9, bit7, LC5CA ; test L00B9 brset L0044, bit6, LC5CA ; VSS fault code? LC5C6 03 D2 01 LC5CA: ldaB L0078 ;last value staA L0078 ; new value xorB L0078 ; any change since last time? staB L00B6 popA ; get Port3 bits 7,6,0 staA L0079 ; Status Flags 4 LC5D5 brclr 94 01 96 ; brclr ?? bitB 132, X ;L0084? stS L0087 tPA nop sBA LC5E1 brclr E5 40 08 brclr LC5EE oraA #%10000000 LC5E8 brset L00E5, 80 02 brset LC5EE LC5EC: bra LC578 LC5EE: negA bra LC5FD LC5F1 brset L00E5, 40 08 brset LC5FD andA #$7F LC5F7 brclr E5 80 02 brclr LC5FD oraA #%00100000 LC5FD: staA L00E5 call LC549 ;appears to be map select ;read A/D channels 0 - 5 ldy #$0054 ;base address of analog registers LC606: ldaA #$00 ;load channel 1 LC608: pushA ;save current channel di call LE5FF ;call A/D conversion ei staA 128, X ;store L00FF ????? popA ;restore current channel incA ;point to next channel cmpA #$05 ;A-5 bcs LC608 ;repeat till 5 channels done aim L0082, L002D ;clear L0082, ATS,WTS,TPS,MAP ; ;WTS ldaB L0054 ;get WTS comB ;invert all bits? cmpB #$12 ;!B - $12 bcs LC624 ;fault?? cmpB #$F6 ;!B - $F6 bls LC62C ;no fault?? LC624: ldaB L98C3 ;B = 94 (default value?) oim L0082, bit6 ;set WTS fault? bra LC645 brset L0081, #$01, LC645 ;brset L0081 bit0 brclr L0094, #$01, LC643 ;brclr L0094 bit0 LC634: subB L006C ;94 – L006C bcc LC63D ldaB L006C decB bra LC645 LC63D: cmpB #$05 bls LC643 ldaB #$05 LC643: addB L006C LC645: staB L006C ;L006C WTS??? LC647 brclr 81 02 0F brclr LC656 ;L0081 ldaA L006C cmpA L991F bcs LC657 oim L00DE, #$08 ;set bit3 L00DE bra LC65A aim L00DE, #$F7 ;clr bit3 L00DE LC65A: ldaA L006C ldY #$FB0B LC660: call LE5B0 ;compare WTS with limits in Y? ldX #$97E3 call LE520 ;tabke look up staA L006D ; manipulates value in A brclr LC678 clrA ; A = $0 ldaB L0054 ; get WTS again comB ; B = -WTS cmpB #$12 ; -WTS - $12 bcs LC678 comA ; A = $FF LC678: staA L00DF ; WTS_Lin or $FF ; ; ATS calcs ; ldaB L0055 ; get ATS Volts comB ; B = -ATS cmpB #$15 ; -ATS_Raw - $15 bcs LC685 cmpB #$F5 bls LC68B oim L0082, #$80 ;set L0082, ATS ldaB L98C6 ;B = $7A LC68B: staB L006E ;default ATS value tBA LdY #$FB0B LC692: call LE5B0 ;compare A with limits in Y ldX #$97F3 ;IAT linearisation table call LE520 LC69B brclr 82 80 09 brclr LC6A8 clrA ldaB L0055 ;get ATS Volts again comB ; B = -ATS cmpB #$15 ; -ATS - $15 bcs LC6A8 comA ;A = $FF LC6A8: staA L00E0 ; ATS_ Lin LC6AA brclr 81 01 07 brclr LC6B5 ;L0081 bit0 call LC50C clrA clrB bra LC6BB ; ; get CAS and calc RPM ; ldD L0224 ; get CAS count call LE471 ; convert to RPM LC6BB: stD L004D ; 004D = RPM/4 call LE595 staB L004F ; RPM/8 ldD L004D ; RPM High call LE593 staB L0050 ; RPM/32 di ldD L0224 ; get CAS count addD L0226 ; add last CAS count stD L00C1 ldD L0228 addD L022A ei addD L00C1 rorA rorB call LE589 call LE471 ; convert to RPM call LE595 ; do something? staB L0051 ; L0051 = modified RPM LC6E8 brclr B3 80 19 brclr LC701? LC6EC 02 B3 7F ldaB L98DC ldaA L004F ;RPM/8 subA L0052 ;RPM modified bcs LC6FB mul bra LC701 LC6FB: negA mul negA negB sbcA #$00 LC701: addD L0052 ; RPM modified stD L0052 LC705 brset L0081, 03 07 brclr LC710 ;L0081, bits2-0 LC709: ldaA L0140 addA #$04 bcc LC715 clrB ldaA L004F ; RPM/8 stD L0052 ; RPM modified LC715: di ldaA L0070 ;TPS Angle LC718 brclr 82 08 03 brclr LC71F oim L0082, bit4 ; set L0082, TPS ei staA L006F ; 6F = TPS ldaA L005B ; TPS Volts cmpA L98C4 ; TPS Volts-$3D bcc LC72E aim L0082, bit5 ;clr L0082, TPS bra LC73B brset L0081, LC73B ;L0081 bit1-0 LC732: cmpA L98C5 bcs LC73B LC737 brset L0078, 80 05 brset LC740 LC73B: ldaB #$08 staB L0129 ldaB L0129 bne LC748 LC745 03 82 20 LC748 brclr L0082, 20 06 brclr LC752 ldaB L989B staB L0128 LC752 CD CE 97 C0 ??? LC756: call LE5E1 staB L00C6 ldaB L006F ;TPS LC75D brclr L0082, #$30, LC76B clrB LC762 brset L0078, #$80,LC76B LC766: ldaB L9847 bra LC79C LC76B: pushB ldX #$9263 ; TPS v WTS Table1a LC76F brclr HWCR, #01,LC776 ldX #$926B ; TPS v WTS Table1b call LE4EA ;Table look up v WTS; popB aBA bcs LC786 LC77D brclr L0078, #$10,LC788 addA L9848 bcc LC788 LC786: ldaA #$FF LC788: clrB ldY #$97D8 ;97D8 = $1400 LC78D: call LE5F8 staB L00C7 ldX #$91D4 ;X is pointer to table at 91D4 ldY #$0800 ;table is 8 rows deep call LE4A3 ;do table lookup LC79C: staB L006B ldX #$0100 LC7A1 brclr 81 03 06 brclr LC7AB ;L0081, bits1-0 ldaB #$50 staB 92, X ;L015C bra LC7DA LC7AB: ldaB Baro_x ;Baro Pressure subB L98C8 bcc LC7B3 clrB LC7B3: cmpB L0167 bls LC7BF LC7B8 02 82 FB clr 92, X ;L015C bra LC7DA LC7BF brset L0082, 30 17 brset LC7DA LC7C3: ldaB L006F ;TPS? cmpB L98C7 bcc LC7DA LC7CA brclr L0094, #01,LC7DA ldaB 92, X ;L015C beq LC7DA decB staB 92, X ;L015C bne LC7DA LC7D7 03 82 04 LC7DA: di ldaA L0059 ; Get MAP_Raw LC7DD brclr 82 01 03 brclr LC7E4 oim L0082, bit1 ;set L0082, MAP ei clrB LC7E6 brset 8A FF 0D brset LC7F7 LC7EA: ldD L0064 ;MAP*4 lslD ;multiply by 64 lslD lslD lslD lslD lslD ;MAP*256?? bcc LC7F7 ldD #$FFFF LC7F7: stD L00C3 ;L00C3 =MAP*256 LC7F8 brset L0082, 30 29 brset L0082, bit5,4, LC821 ;bra if L0082, TPS LC7FC: bvs LC794 ;bra if overflow negA subA L00C3 ;L00C3 bcc LC804 clrA LC804: pushA ldX LUT_9002 ;MAP v WTS Table1a LC808 brclr HWCR, #$01, 03 brclr C80F ;test bit0 L00D7 ldX LUT_900A ;MAP v WTS Table1b call LE4EA ;Table look up MAP v WTS popB mul pushA ldX #$9012 ;Table look up MAP v WTS v RPM call LE4FB ;Table look up v RPM popB mul tAB ldaA L00C3 ;L00C3 sBA bcc LC824 clrA LC824: staA L00C3 ;L00C3 ldD L00C3 ;L00C3 LC828 brclr 82 06 LC82F ; branches here ldaA L006B ;A = L006B clrB ;D = L006B, 00 LC82F? stD L005C ; D=MAP*51.5 MAP/5 ldX #$936F call LE4FB ;Table look up MAP v RPM staA L0119 ldX #$937D call LE4FB ;Table look up MAP v RPM staA L011A brclr HWCR, bits5,4, LC865 ;test bits 4, 5 L00D7 ; ; ;Bit4=0 so branch LC847 brset L0081, 01 04 ;L0081 bit0 LC84B brclr L0081, 02, LC854 ;L0081 bit1 aim L00DE, #$DF ;clear bit5 L00DE bra LC868 LC854 brset L0082, 40 LC865 LC858 brset L0078, 10 LC865 LC85C brclr L00DE, 08 LC865 LC860 oim L00DE, 10 ;set bit4 L00DE bra LC868 aim L00DE, #$EF ;clear bit4 L00DE LC868 brclr HWCR, #$02, LC892 ;test bit1 L00D7 LC86C brset L0078, 40, LC875 ldaA #$0C staA L013B LC875 brset L004A, 09 LC892 LC879: ldaA L0141 addA L993A bcc LC892 tst L013B bne LC892 ;check battery voltage is above 7.52V ldaA L0058 ;get Batt_Raw cmpA L9937 ;A - $66 (7.52V) bcc LC895 ;Batt voltage OK oim L00E6 ;Set flag if Batt voltage low bra LC895 ; LC892: aim L00E6, #$7F ;clear bit7 L00E6 LC895: brset L00E6, bit7, LC89E ;bra if bit7 L00E6=1 ldaA #$78 ;do this if bit7 LE006=0 staA L013A ret ; ; ****************************************************************************************** ; *************************** SUBR 5 ******************************************************* ; ****************************************************************************************** ; SUBR5: brset L0048, bit1, LC91D ;return with 03 in L0185 LC8A3: ldaA L004B ;Load A with contents of 4B andA #%01110010 ;and with $72 beq LC91D ;bra if 72, fault test?? staA L00C2 ;store result in C2 oim L00E6 #$20 ;set bit5 L00E6 ldX #$016F ;Load X with #$016F ldD #$0404 ;Load D with #$0404 LC8B4 brset L00E6; 01 18 brset L00E6 ;bra to LC8D0 if E6 bit0 set LC8B8: ldX #$0173 ;Load X with #$0173 ldaA #$08 ;Load A with 08 LC8BD brset L00E6, 02 0F brset ;bra to LC8D0 if E6 bit1 is set LC8C1: ldX #$0177 ;Load X with #$0177 ldaA #$0C ;Load A with #$0C LC8C6 brset L00E6, 04 06 brset ;bra to LC8D0 if E6 bit2 is set LC8CA: ldX #$0183 ;load X with #$0183 ldD #$0202 ;Load D with #$0202 brclr L00E6 #$40, LC8DF ;L00E6 bit6 = Write?? LC8D4: call LC396 ;Call I2C write tstB ;B = 0?? bne LC8E5 ;if B!=0 oim L00E6, #$40 ;if B=0 then set bit 6 L00E6 bra LC91D bra LC2DD ;I2C READ tstB beq LC8E8 ; B = ??? LC8E5: jmp LC9B8 aim L00E6 #$BF ;clear bit 6 L00E6 LC8EB brclr L00C2, 02 31 brset L00C2 #$02 LC920?? LC8EF brclr L00E6, 01 17 brset L00E6 #$01 LC90A?? aim L00E6 #$FE ;E6 bit7 oim L00E6 #$02 ;L00E6 bit1 LC8F9 03 4A 02 LC8FC: ldD L017F stD L0173 ldD L0181 stD L0175 bra LC8AB LC90A brclr L00E6, 02 0C brclr L00E6 aim L00E6, #$FD oim L004C, #$2 oim L0049, #$2 call LC9E0 LC91A 02 4B FD LC91D 7E C9 DA LC91D: jmp LC9DA ;load 03 into L0185 and rtn; ; LC920 brclr L00C2, 40 6C ;store data to be sent to SEEPROM? LC924 brclr L00E6, 01 14 brclr L00E6 aim L00E6, #$03 oim L00E6, #$02 ldD L016F ;L016F stD L0173 ldD L0171 stD L0175 bra LC96A LC93C brclr L00E6, 02 14 brclr L00E6 aim L00E6, #$FD oim L00E6, #$04 LC946: ldD L016F ;L016F stD L0177 ldD L0171 stD L0179 bra LC96A ; ; programme the test bytes ?? ; LC964: ldD #$5AA5 ;5AA5 ;programme the test code stD L0183 jmp LC8AB ; brclr L00E6, bit3, LC984 ;do something if E6 bit3 = 1 aim L00E6, #$F7 oim L004A, #$40 oim L0049, #$40 bsr LC9E0 ;I2C failure? LC97C brset L00E6, 10 05 brset L00E6 aim L0048, #$F7 bra LC988 oim L0048, #$08 aim L00E6, #$EF aim L004B, #$BF bra LC9DA LC990 brclr L00C2, 10 10 oim L004A, #$10 oim L0049, #$10 aim L004B, #$EF aim L00E6, #$FE bsr LC9E0 bra LC9DA LC9A4 brclr L00C2, 20 32 LC9A8 03 4A 20 LC9AB 03 49 20 LC9AE 02 4B DF LC9B1 02 E6 FD aim L00E6 bsr LC9E0 bra LC9DA ; LC9B8: tst L0185 beq LC9C2 dec L0185 bra LC9DF LC9C2 03 48 02 ldaA L0049 oraA L00C2 staA L0049 ldaA L004B com >L00C2 andA L00C2 staA L004B LC9D4 02 E6 80 aim L00E6 clr L013A LC9DA: ldaA #$03 staA L0185 LC9DF: ret ; ;called when I2C Read failed LC9E0: ldD L016F ;L016F stD L017F ;store Double L016F in L017F ldD L0171 stD L0181 ;store Double L0171 in L0181 ldD L0177 xorA L0173 ;XOR L0177 with L0173 xorB L0174 stD L017B ;store result in L017B ldD L0179 stD L017D ;store L0179 in L017D ret ; ****************************************************************************************** ; *************************** SUBR 6 ******************************************************* ; ****************************************************************************************** SUBR6: tst L013A bne LCA28 LCA04 03 49 80 oim L0049, #$80 LCA07 brset L0048,08 20 LCA0B brclr L0049,01 14 LCA0F brset L004C, 01 18 LCA13 brset L0049, 02 14 brset Brclr L0049, 49 08 08 brclr Brclr L004A, 08 0C brclr Brset L0049, 20 08 brset 03 48 04 oim bra LCA2B ; LCA28 02 48 FB aim LCA2B brclr L0049, 01 2E brclr Brset L004A, 01 22 brset Brset L004C, 01 19 brset LCA37 brset L004C, 04 11 LCA3B brclr L0049, 08 04 Brset L004A, 08 12 LCA43 brset L0043, 40 16 brset nop ;x 3 bra LCA4C brset L004A, 08 05 brset LCA50 03 48 01 LCA53 20 0C bra LCA55 aim L0048 #$FE ;clear L0048 bit 0 LCA58 02 4A 7F LCA5B 20 11 bra ; LCA5D brclr L0049, 80 09 LCA61 brset L0043, 40 05 LCA65 03 4A 80 LCA68 20 0F LCA6A brset L004A, 80 0B LCA6E brclr L0043, 20 0C LCA72: di call LC2CE ; setup I2C port ei bra LCA7E ; localret LCA79: di call LC2B5 ; setup I2 port ei ret ; ****************************************************************************************** ; *************************** SUBR 7 ******************************************************* ; ****************************************************************************************** LCA7F brclr L00E5, 80 46 LCA83 brclr L00E5, 20 3A LCA87: ldaA L0139 addA L9939 bcs LCAC1 ldaA #$FF staA L0125 staA L0141 di LCA98 brclr L0049, 80 24 LCA9C brset L004B, 72 20 LCAA0 02 4B 80 LCAA3: ldaA #$78 staA L013A LCAA8 brset L004A, 09 0B LCAAC: clrA staA L0049 staA L004C oraA #%10000000 staA L004A bra LCABD ; LCAB7 02 4A 7F 02 49 7F LCABD 02 43 BF LCAC0: ei ldaA L9938 staA L0139 bra LCAD4 ; LCAC9: ldaA L013A cmpA L0139 bls LCAD4 staA L0139 LCAD4: tst L0139 bne LCAE7 di LCADA brset L004A, 09 03 LCADE 03 4A 80 LCAE1 02 43 7F LCAE4: jmp LF742 LCAE7: ret ; ; ; SUBR8: ldX #$94D1 ; X = L94D1 ldaA L0051 ; get RPM ldaB L007A ; get L007A ?? lsrB call LE61A ldaA L0050 ;RPM manipulated call LE60E staB L007A ldaB L007B lsrB call LE60C staB L007B ldaB L007C lsrB ldaA L005C ;MAP/5 call LE612 rorB rorB rorB staB L007C ldaB L007D lsrB ldaA L006C call LE60E rorB staB L007D ldaB L007E lsrB call LE60C staB L007E ldaB L007F lsrB ldaA L006F ;TPS call LE60E rorB staB L007F ldaB L0080 lsrB ldaA Baro_x ;Baro Pressure call LE618 ldaA L0093 ;VSS call LE616 ;test bits? ldaA L006C call LE616 ;test bits? staB L0080 ldaB L00DC lsrB ldaA L006F ;TPS call LE618 ; ldaA L0050 ;RPM manipulated call LE610 staB L00DC ldaB L00E4 lsrB ldaA L0058 ;get Batt_Raw call LE61A ldaA L0093 ;VSS call LE61A ldaA L006C call LE61A ldaA L0050 ;RPM manipulated call LE612 staB L00E4 ldX #$9239 call LE4FB ;Table look up v RPM LCB6F brclr 78 10 03 addA L982C pushA ldaA L982D ldaB Baro_x ;Baro Pressure mul addD #$0080 subA L982E bcc LCB86 clrA LCB86: popB mul addD #$0040 lslD bcc LCB90 ldaA #$FF LCB90: cmpA L005C ;MAP/5 LCB92: bhi LCBA3 LCB94 brset L007C, 20 05 LCB98: tst L0145 beq LCBA3 ldaB L982F staB L0145 LCBA3 brset L007C, 20 03 LCBA7: addA L982B LCBAA 02 7C DF cmpA L005C ; MAP/5 bhi LCBB4 LCBB1 03 7C 20 ldX #$9247 call LE4FB ;Table look up v RPM ldaB Baro_x ;Baro Pressure subB L9834 bcc LCBC2 clrB LCBC2: cBA bcs LCBC6 tBA LCBC6: staA L011F LCBC9 brclr L007C, 40 06 subA L9835 bcc LCBD3 clrA LCBD3: cmpA L005C ;MAP/5 bhi LCBDC LCBD7 03 7C 40 LCBDA 20 10 bra LCBDC 02 7C BF ldaA L9832 brclr HWCR, bit0, LCBE9 ;test bit0 L00D7 = (0) ldaA L9833 staA L0146 ldX #$9255 call LE4FB ;Table look up v RPM LCBF2 brclr 7F 80 06 clr subA L9845 bcc LCBFC clrA LCBFC 02 7F 7F cmpA bhi LCC03 03 7F 80 brclr 81 03 25 ;L0081 bits1-0 02 C0 0F LCC0D: ldaA L006C cmpA L98B1 bcs LCC17 oim L00C0, #$80 LCC17: cmpA L9883 bcs LCC1F oim L00C0, #$80 LCC1F: cmpA L98AF bcs LCC27 oim L00C0, #$20 LCC27: cmpA L98E2 bcs LCC2F LCC2C 03 C0 10 subB #$10 LCC2F: ldX #$0100 LCC32 brset HWCR, bit5-4,LCC39 ;L00D7 4=(0) LCC36: jmp LCCC2 ; LCC39: ldaA 83, X ;L0183 beq LCC45 xgDX inc L4004 LCC41 brset L0081, 10 05 ;L0081 bit4 LCC45: ldaA L9914 staA 79, X ;L0179 ldaB 79, X bne LCC62 ldaA 87, X ;L0187 – Calif codes??? bne LCC5D ldaB L00E3 beq LCC5D cmpB #$FF beq LCC5B decB LCC5B: staB L00E3 LCC5D: ldaA L9915 ;=$64 staA 87, X ;L0187 LCC62: ldaA L0093 ;VSS cmpA L9923 bcc LCC6E ldaB L9913 staB 80, X ;L0180 LCC6E: ldaA L0050 ;RPM/32 beq LCC79 ldaA L0093 ;VSS clrB bclr L0050, #%00101000 ;RPM manipulated LCC78 02 C6 FF staB L00D6 LCC7D 02 DE BF LCC80: brset HWCR,bit5,LCC90 ;test bit5(1)L00D7 LCC84: cmpB L9921 bcc LCC9D cmpB L9920 bcs LCC9D bra LCC9A ; LCC90: cmpB L9925 bcc LCC9D cmpB L9924 bcs LCC9D LCC9A 03 DE 40 LCC9D: ldaA L00E3 beq LCCBD LCCA1 brclr DE 40 18 LCCA5: ldaA L0093 ;VSS cmpA L9923 bcs LCCB0 ldaB 80, X ;L0180 beq LCCBD LCCB0: cmpA L9922 bcs LCCBD ldaB 87, X ;L0187 bne LCCBD LCCB9 brset L0081, 10 05 ;L0081 bit4 ldaA L9916 staA L0052 ; RPM modified LCCC2: ldaA L0093 ;VSS LCCC4 brset HWCR, bit5-4, LCCD0 ;test bit5-4 L00D7(1,0) LCCC8: cmpA L9843 bcs LCCD0 oim L00DE, #$02 LCCD0 brset L007D, 10 05 LCCD0: brset LCCD4: ldaA L985F staA 88, X ldaA 88, X bne LCCEE ldaA 19, X ;L0119 bne LCCEE ldaA L00F4 bne LCCEE LCCE5 brset L00D2, 01 05 LCCE9 02 97 BF bra LCCF1 LCCEE 03 97 40 LCCF1 brset L0078, 80 0E LCCF5: ldaA L982A staA 43, X ;L0143 LCCFA brclr L00B6, 80 05 ldaA L992B staA 56, X ;L0156 LCD03 brclr L0078 20 05 LCD07 ldaA L98B0 LCD0A staA 55, X ;L0155 LCD0C 02 97 EF LCD0F brset L007D, 02 06 LCD13 brclr L007A, 20 17 LCD17 20 12 bra Brset L00D2, 01 04 brset Brset L007D, 04 06 Brclr L007A 08 09 20 04 bra brclr 7A 04 03 03 97 10 Brset L0083, 40 10 Brclr L00E5, 80 0C LCD36 brclr HWCR, #$02, LCD3E LCD3A brset L0043, 20 04 ; LCD3E: ldaA 42, X bne LCD47 ldaA #$01 jmp LCF5F ; LCD47 brclr L0079, 40 0C LCD4B brset L007A, 01 08 LCD4F 86 02 LCD51 02 DE FD LCD54: jmp LCED3 LCD57 brclr 7A 04 4F LCD5B: ldaB L0050 ;RPM manipulated cmpB L94D6 bcc LCD66 LCD62 brclr L0081, 04 44 ;L0081 bit2 LCD66 brset L0082, 82 06 04 ;L0082 bits2-1 (MAP?) LCD6A brset L007C, 7C 01 2C brclr 78 80 28 LCD72 brset HWCR, #$01, 10 ;test bit0 L00D7 LCD76: ldaB 43, X beq LCD86 LCD7A brclr L0081, 04 04 brclr L0081, bit2, LCD82 ;L0081 bit5 LCD7E brset L0083, 20 04 brset L0083, bit5, LCD86 LCD82 brset L00B9, 20 14 brset L00B9, bit5, L LCD86: ldaB 84, X ;L0184 addB L9829 bcs LCD9A LCD8D brclr L0097, 10 09 ldaB 19, X bne LCD9A LCD95 03 83 20 20 17 bra LCD9A brset L0082, 06 0C brclr L007D, 04 08 brset L007C, 20 04 LCDA6: ldaB 69, X LCDA8 27 04 beq LCDAE LCDAA brclr L007A, 10 08 LCDAE 02 83 DF ldaA #$04 LCDB3 jmp LCED3 LCDB6 brclr L0082, 06 10 ldaA #$80 LCDBC brset L0082, 30 07 brclr L007F, 80 03 LCDC4: jmp LCEC9 LCDC7: jmp LCE95 LCDCA brclr L007C, 40 1F LCDCE brclr 81 10 1B ;L0081 bit4 LCDD2 brclr HWCR, 20 0C ;test bit5 L00D7 LCDD6: ldaB L0050 ;RPM manipulated cmpB L991B bcs LCDED cmpB L991C bcc LCDED LCDE2: brclr 94 08 07 ldaB L00E2 beq LCDEB decB LCDEB: staB L00E2 LCDED: brclr HWCR 30 23 ;test bit4,5 L00D7 brset 7C 40 13 ldaA L9911 staA 81, X ?? ldaB 82, X bne LCE03 LCDFE 03 DE 80 bra LCE06 ; LCE03 02 DE 7F LCE06: bra LCE14 ; LCE08 brclr DE 80 08 LCE0C 02 DE 7F B6 99 10 ldaA LCE12 A7 53 staA LCE14: ldaB L0078 andB #%10000110 cmpB #$84 beq LCE90 LCE1C brclr 7C 40 74 LCE20 brset 81 08 6C ;L0081, bit3 LCE24 brclr HWCR 30 4A ;test bits4,5 L00D7 brclr DE 10 64 LCE2C: ldaA L006C cmpA L991D bcs LCE90 cmpA L991E bcc LCE90 ldaA 83, X bne LCE94 ldaA L0050 ;RPM manipulated LCE3E brset HWCR 20 0C ;test bit5 L00D7 LCE42: cmpA L9918 bcs LCE90 cmpA L9919 bcc LCE90 bra LCE58 ; LCE4E: cmpA L991B bcs LCE90 cmpA L991C bcc LCE90 LCE58: ldaA L006F ;TPS LCE5A brset HWCR, 20 05 ;test bit5 L00D7 LCE5E: cmpA L9917 bra LCE66 ; LCE63: cmpA L991A bcc LCE90 ldaB L00E2 beq LCE90 ldaB 81, X beq LCE90 bra LCE94 ; LCE72: ldaB 91, X bne LCE90 ldaB TfStart ;time from start addB L9830 ;test limit1 = (0-5D) = A3 bcs LCE90 ldaB L9831 addB TfStart ;test limit2 = (0-74) = 8C bcc LCE90 LCE84 brset 82 30 08 LCE88 brset 7F 02 04 LCE8C: ldaB 70, X bne LCE94 ldaA #$08 bra LCED3 ; ;Is this the start of the L0081 tests???? ; LCE94: clrA ldaB 45, X bne LCEC9 LCE99 brset 82 40 2C brset 7D 01 13 LCEA1: ldaB 91, X bne LCEC9 LCEA5 brclr DE 02 20 brset 7E 08 07 LCEAD: ldaB TfStart ;time from start addB L983F ;test limit = (0-D)= F3 bcs LCEC9 LCEB4 brclr 95 10 11 ; L0095 O2 status ldaB L00F4 beq LCEC7 LCEBC brset L0081 10 07 ;L0081 bit4 LCEC0: ldaB L0074 cmpB L983C ; B=#$2E? bcs LCEC9 oraA #%00010000 ;L0081 bit4??? LCEC9 brclr L0078 80 06 LCECD brset L007A 02 02 oraA #$20 ;L0081 bit5? LCED3: bitA #%00001000 bne LCF25 LCED7 brset HWCR 20 4C ;test bit5 L00D7 LCEDB brset L0082 06 46 brclr L0080 02 7C LCEE3: ldaB L0091 bne LCEEB LCEE7 brclr L007B 80 74 LCEEB brset L00C0 80 06 LCEEF brclr L0080 80 6C LCEF3 bra LCEFD LCEF5 brclr L007D 08 66 LCEF9 brset L0080 80 14 LCEFD brset L0082 30 22 LCF01 brset HWCR 01 06 ;test bit0 L00D7 LCF05 brclr L007F 04 56 LCF09 bra LCF23 LCF0B brclr L00DC 01 50 LCF0F bra LCF23 LCF11 brset L0082 30 0E LCF15 brset HWCR 01 06 ;test bit0 L00D7 LCF19 brclr L007F 08 42 LCF1D bra LCF23 LCF1F brclr L00DC 02 3C LCF23: oraA #%01000000 bra LCF5F LCF27 brset L0078 C0 34 LCF2B brset L0046 70 30 LCF2F brset L0077 80 2C LCF33 brclr L00E4 01 28 LCF37 CF 6D 01 0E ;mystery op code ???? LCF3B CF 6E 01 20 LCF3F brclr L007D 08 1C LCF43 brclr L00E4 80 18 LCF47 bra LCF5D LCF49 brset L0082 06 12 LCF4D brclr L0080 02 0E LCF51: ldaB 56, X bne LCF5D ldaB L0091 bne LCF5D brclr L007B, bit7, LCF5F LCF5D: oraA #%01000000 ;L0081 bit6?? LCF5F: staA L0081 ;store L0081 ; ; brclr L0081,bit2, LCF70 ;L0081 bit2 ldaB 44, X ;L0144? bne LCF7C ldaB L983B staB 45, X bra LCF7C ; LCF70: ldaB L9839 ;9839 = $50 xgDX ;X = ?50 staB P2DDR oim L00F6, bits 7,4,3 abX staB 44, X ret ;SUBR9 – Fuelling Calculations SUBR9: ldX #$92AA call LE4FB ;Table look up v RPM with limits brclr L007C, bit7,LCF8A LCF87: addA L986B ; A + $05 aim L007C,#$7F ;clear L007C bit7 cmpA L005C ;MAP/5 bhi LCF94, oim L007C, bit7 ;set L007C bit7 brclr L0078, bit7, LCFA5 ldaA L9884 ;A = 3C ldaB L0050 ;RPM/32 cmpB L9885 ;B - $2B (1376rpm?) bcc LCFA3 clrA LCFA3: staA L008B LCFA5: brclr L0081,bit2,LCFAE ;L0081 bit2 ldaB L9893 ;B = $3C = 60 staB L008C brset L00DA,bit1,LCFD8 oim L00DA,bit2 ;set L00DA, bit2 bra LCFD8 brclr L00DA, bit2,LCFD8 aim L00DA,#$FB ;clr L00DA, bit2 lsrD L000C ;0C,0D /2 aim L00DA,#$FB ;clr L00DA, bit2 LCFD4: sev ;set 2’s comp ovflw bit? addA L989C ;A + $09 bcs LCFDC ;bra >255 bpl LCFE6 ;bra if +ve LCFDC: ldaA #$80 bra LCFE6 LCFE0: subA L989D ;A - $09 bcc LCFE6 ;bra A=>9 clrA LCFE6: staA L018A ;L018A = A brclr L0095,bit4,LCFF1 ;O2 Sensor flags bit4 brset L0095, bit1,LCFF5 ;O2 Sensor flags bit1 rich/lean? brclr L0081, bit2,LCFFA ;L0081 bit2 LCFF5: ldaA L988E ;A = $50 = 80 staA 48, X ;A -> ?? aim L0083, #$7F ;clr L007F, bit7 ldaB L006C brset L0083,bit6,LD052 ;L0082 brset HWCR, bit0, LD024 ;config bit0 LD007: ldaA 91, X ;A = ? beq LD00F ;A=0? brclr L00C0, bit6, LD02C cmpB L9882 ;B-$D0 LD012: bcc LD02C brset L0082,bits5-4,LD02C LD018: ldaA L006F ;get TPS Angle cmpA L9881 ;TPS - $44 bcs LD02C ;bra TPS<$44 (68%?) oim L0083, bit7 ;set L0087 bit7 bra LD02C ldaA 91, X ; get here from config beq LD034 LD028 brset C0 40 08 brset LD034 ;bra again (config) LD02C: ldaA L988C ;A = $13 cmpB L988A ;B - $9F bra LD03A LD034: ldaA L988D ;A = $0A cmpB L988B ;B - $7C LD03A: bcc LD040 brset L0081,bit3,LD057 ;L0081 bit3 brset HWCR,bit0,LD050 ;config bit0 brclr L00DA,bit3,LD04C brset L00F6,any,LD057 brset L0081,bit3,LD052 ;L0081, bit3 LD050: staA L00DD ;L00DD = $0A or $13 aim L00DA, #$F7 ;clr L00DA, bit3 bra LD05A ; oim L00DA, bit3 ;set L00DA, bit3 LD05A: ldaA #$80 ;A=$80 brset L0078, bit5, LD077 brset L0094, bit1, LD078 LD063: bclr L00A6, #%00011101 ;clr L00A6 bits4-2,0 beq LD079 ldaB 91, X ;B = ? bne LD071 subA L98A6 ;A - $04 bra LD074 LD071: subA L98A5 ;A - $02 LD074: bcc LD077 clrA LD077: staA 29, X brclr L0081,bit1,LD082 ;L0081 bit1 ldaA L98A1 ;A = $32 staA 93, X ;where?? brset L0078, bit5,LD091 LD086: ldaA 93, X ;?? beq LD091 brclr L0094,bit1,LD091 decA staA 93, X brclr HWCR,bit0,LD09E ;test bit0 L00D7 ldaA L00FA beq LD0AF ldaB L9850 ;B = $78 bra LD0A5 brset L0078,bit7,LD0AF ldaB L984F ;B=$C8 oim L00DA, bit6 ;set L00DA, bit6 aim L00DA, bit7 ;clr L00DA, bit7 staB 66, X ;L0166? clr 47, X ;?? brclr L0094,bit0,LD0EB ldaA 96, X beq LD0BA decA bne LD0E9 LD0BA: ldaA 24, X addA L9851 ;A+3 cmpA L005C ;MAP/5 rol L011E ldaA L005C ;MAP/5 staA 24, X ;store where??? ldaA 30, X andA #%00000011 ;isolate bits 1-0 cmpA #$03 ;A - $3 bcs LD0DF ;bra A<3 oim L00DA,bit7 ldaA L984D ;$78 again brclr HWCR,bit0,LD0DD ;test bit0 L00D7 ldaA L984E ;A = $3C again staA 47, X ; = $3C LD0DF: ldaA L984B ;A= $20 brclr L00D7,bit0,LD0E9 ldaA L984C ;A=$06 LD0E9: staA 96, X ldaB L0095 ;O2 Status Flags clr >L00C1 ;clear L00C1 brset L0081,bits1-0,LD127 ;L0081, bit1-0 LD0F4: ldaA 64, X addA L9840 ;A=$14 bcs LD127 oim L00C1,bit6 ;set L00C1 bit6 brclr L00D7, bit5,LD113 ;test bit5 L00D7 ldaA L0096 ;L0096 cmpA #$0A ;L0096-$0A bcs LD10A ;bra A<$0A subA #$0A ;else A-$0A LD10A: cmpA #$08 ;A-$08 bcs LD113 ldaA L983D ;A=$3D bra LD116 LD113: ldaA L983C ;=$2E? LD116: cmpA L0074 ;L0074 = O2 sensor bhi LD11D oim L00C1 bit1 ;L00C1 bit1 LD11D: ldaA L983C ; =$2E 46 =0.9V cmpA L005A ; 0.9V – O2 sensor*2 bhi LD127 oim L00C1 bit0 ;5A < 0.9V set bit0 LD127: xorB L00C1 ;L00C1 bitB #%00000010 ;test AccB bit 1 beq LD130 oim L00C1, bit3 ;set L00C1 bit3 LD130: bitB #%00000001 beq LD137 LD134 03 C1 04 LD137: ldaA L0095 ;O2 Status Flags andA #%10110000 oraA L00C1 staA L0095 ; O2 Status Flags LD13F brclr 81 03 05 ;L0081 bit1-0 LD143 aim L0095, #$CF ; O2 Status Flags clr bits5-4 bra LD17E LD148 brclr L0095 04 03 oim L0095 #$10 ;O2 status bit 4 LD14F: ldaA L9841 LD152 brclr L0095 08 02 staA 86, X LD158 brset 81 10 05 ;L0081, bit4 aim L0095 #$DF ; O2 Status Flags clr bit5 LD15F: bra LD17E ; LD160 brset L0095 20 05 oim L0095 #$20 ;O2 status set bit5 LD167: bra LD110 LD169: rorB ldaB L005C ; MAP/5 cmpB L9842 ; = $36 bcc LD177 LD171 brclr L0097 02 02 staA 86, X LD177: ldaA 86, X bne LD17E LD17B aim L0095 #$EF ;O2 status clear bit4 LD17E brclr L0081 10 04 ;L0081 bit4 LD182 brclr L0095 08 05 ; O2 Status Flags bit3 ldaA L986F staA L00F2 ; counter?????? brclr L0081, bit4, LD196 ; L0081 bit4 ldaA L005A ; O2 Sensor cmpA L986C ; O2 sensor – 0.6V bcs LD19B ; bra if O2 <0.6V ldaA L986D ; = $28 = staA 85, X bclr L0081, bit1, LD1A9 ;L0081 bit1 ldX #$928B ;L928B or L9293 brclr L00D7, bit0, LD1A9 ; config bit ldX #$9293 call LE4EA ;Table look up v WTS staA L00F4 bra LD1C4 ; LD1B0 brclr L0079 40 04 LD1B8 brset PORT6 08 5A ;Throttle Opener VSV? LD1B8: ldaB L012E bne LD1C4 ldaA L00F4 beq LD1C4 decA staA L00F4 LD1C4: ldaA L00F4 tst L015B beq LD1D1 LD1CB brclr L007D 01 1D bra LD1D5 ; LD1D1 brclr L007E 08 17 ; LD1D5: ldaB L9859 LD1D8 brset L007E 40 03 ldaB L9858 LD1DF brset L0081 08 09 ;L0081 bit3 LD1E3 brset L0078 80 1C LD1E7: cmpA L985A bhi LD203 ; LD1EC brset L00D7 01 08 ;test bit0 L00D7 LD1F0: ldaB L9856 cmpA L9853 bra LD1FE ; LD1F8: ldaB L9857 cmpA L9854 bls LD203 ldaB L9855 LD203 brset L0081 02 08 ;L0081 bit1 LD207: ldaA L012E beq LD20F cBA bls LD212 LD20F: staB L012E LD212: clrB LD213 brset L0081 20 18 ;L0081 bit5 LD217 brclr L007C 02 06 LD21B: incB LD21C brclr L007C 04 01 inc L0401 incB ldaA #$03 mul LD224 brclr L007B 01 06 LD228 incB Brclr L007B 02 01 incB incB LD22F brset L0081 80 0C ;L0081 closed/open LD233 brset L0080 02 08 LD237: cmpB #$07 bcs LD23D subB #$03 LD23D: addB #$0A ldaA L0096 staB L0096 cBA beq LD288 ldX #$0202 ldaB L0096 lslB aBX ldaA 1, X clrB stD L00ED ldaA 0, X bne LD281 ; LD256 brset L0081 20 27 ;L0081 bit5 Brclr L0080 02 13 Brset L0080 01 0F brclr L007C 04 0B xgdx LD267: subB #$06 xgdx LD26A: ldaA 0, X bne LD281 ldaB #$06 aBX LD271 brset L007B 02 0C LD275: incX incX tst 0, X bne LD281 ; LD27B brset 7B 01 02 LD27F: incX incX ldaA 0, X staA L00EC call LE423 clrB brset L0081, bit7, LD293 ; L0081 open loop? LD28D: ldaA #$80 ; zero the STFT staA STFT ; STFT oraB #$01 LD293 brset L0081 20 02 ;L0081 bit5 LD297: oraB #$02 LD299 brclr L00DA 10 02 oraB #$04 LD29F brset L0097 08 02 oraB #$08 brclr L0097 04 02 oraB #$10 brclr L0078 10 07 LD2AF: ldaA L018A beq LD2B6 oraB #$40 LD2B6: ldaA L00F6 bne LD2BE ldaA L00FA beq LD2C0 LD2BE: oraB #$20 LD2C0: tBA ;D = BB xorB L00DB andB L00DB staA L00DB bitB #%00000001 bne LD2EC bitB #%00000010 beq LD2DC ldaA L0091 bne LD2EC ldaA L0143 bne LD2EC LD2D8 brclr 97 40 10 LD2DC: bitB #%01011100 beq LD2E4 ldaA L00E9 bpl LD2EC LD2E4: bitB #%00100000 beq LD2F1 ; ;Check to see if we want to do closed loop calcs ; LD2E8 brset L0081 20 05 ;L0081 bit5 LD2EC ldX #$8000 ;zero a 16-bit signed value? LD2EF: stX L00E9 LD2F1 brclr L0081,bit4,LDA4A ;L0081 bit4 brset L0081 80 71 ;open/closed loop? brset L0044 FF 6D ;test fault codes1 brset L0046 FF 69 ;test fault codes2 brset L0082 F6 65 ;L0082 bits TPS, MAP LD305 brclr L00D7 20 07 ;test bit5 L00D7 (config?) LD309: ldX #$0100 LD30C C7 6D 01 5A LD310 brclr L0078 04 04 brclr L0078 02 52 brclr L007E 01 4E brset L007E 02 4A LD320 brset L007B 08 46 brclr L007C 80 42 brset L007B 04 04 brset L007C 08 3A LD330 brset L0081 20 0F ;L0081 bit5 LD334 brset L0078 80 32 LD338 brclr L0078 10 07 ldaA L006F ;TPS cmpA L986E bcs LD36A ldaA L011C bne LD36A ldaA L00F4 bne LD36A LD34C brset L00DA 10 1A brset L00DB 20 16 brset L0097 04 12 brclr L0078 10 05 LD3DD: ldD L00ED addD #$0080 ldaB L00EC bne LD3E8 ldaB #$80 LD3E8: mul lslD addD #$0080 brclr L0081, bit7, LD3F3 ;branch if open loop ldaA #$80 ;zero LTFT? staA LTFT ;LTFT LD3F5 brclr L00D7 20 2B ;test bit5 L00D7 clrb sei LD3FB brset L0077 80 21 LD3FF: ldaA L018D beq LD420 subA L992E bls LD420 lslA staA L00C1 ldaA L016A subA L992E bls LD420 bclr L00C1, #%00100101 lslD cmpB L992C bcs LD420 ldaB L992C LD420: staB L018C ei LD424 brclr L0081 05 08 ;L0081 bits3,0 ldD #$0064 stD L00FE ;Inj PW = 100 (fuel cut) jmp LD7A6 ; ; LD430 brclr L0081 02 3F ;L0081 bit1 LD434: ldX #$9224 call LE4EA ;Table look up v WTS pushA ldaA L004E ;RPM Low? ldY #$8020 LD441: call LE5B0 ;compare A with limits in Y ldX #$922C call LE51D pushA ldaA Baro_x ;Barometric reading ldaB L9826 mul addA L9827 popB mul lslD bcc LD45B ldaA #$FF LD45B: popB mul lslD bcc LD463 ldD #$FFFF LD463: stD L00FC LD465 brset 82 30 07 LD469: ldaB L006F ;TPS cmpB L9828 bcc LD428 jmp LD748 ; ; MAP*51.5 is multiplied by 211/8 (26.375) = (millibar*2) LD473: ldD L005C ;MAP*51.5 lsrD lsrD lsrD ;MAP_Raw*32 stD L00C1 ; ldaB L9838 ;L9838 = 211 call LE460 ;MAP_RAW*211 stD L00FC ;store ms bytes in FC,FD ldY #$97AA ;Y is pointer to L97AA LD486: call LE5E1 ;get modified RPM staB L00C6 ;RPM = X Axis? ldy #$97CB LD48F: call LE5E7 ;get modified MAP staB L00C7 ;MAP = Y axis? ldY #$1000 ;Y = table size ?x16 ldX #$9C00 ;X is pointer to fuel map 2 brset L00D7, #$20, LD4A2 ;config bit 5 ldX #$9020 ;X is pointer to fuel map 1 call LE4A3 ;do table lookup staA L011B ;store result??? brclr L0081, bit5, LD50A ;faults flagged?? LD4AC: ldaB L00C6 cmpB #$B0 bcs LD4B6 ldaB #$B0 staB L00C6 brset L00D7, bit5, LD4C4 ;test bit5 L00D7 LD4BA: ldaB L00C7 cmpB #$E0 bcs LD4C4 ldaB #$E0 staB L00C7 ldY #$0C00 ;Y is table size ?x12 LD4C8: ldX #$9D00 ;X is pointer to table at L9D00 brset L00D7 #$20, LD4D2 ;test map select bit LD4CF: ldX #$9120 ;or X is pointer to L9120 call LE4A3 ;do table lookup ldaB L018C LD4D8 brset D7 20 22 ;test bit5 L00D7 LD4DC: pushA clrB LD4DE brset 78 80 1B brclr 78 10 15 brset 82 30 11 LD4EA: ldaA L006F ;TPS subA L9849 bcc LD4F2 clrA LD4F2: ldaB L984A mul cpD #$0080 bcs LD4FD ldaB #$80 LD4FD: popA mul lslD negA beq LD50A ldaB L011B mul staA L011B LD50A: ldaA L011B call LE53B lsrD ;shift D right 1 bit stD L00FC ldX #$0100 clrA LD517 02 DA EF ldaB 91, X beq LD54F ; LD51E brset DC 40 2D brset 81 80 29 ;L0081 open/closed loop LD526 brclr D7 01 06 ;test bit0 L00D7 LD52A: ldaB L00FA bne LD54F bra LD534 ; ; LD530 brclr 78 80 1B ; LD534: ldaB 66, X ;L0166?? beq LD54F LD538 brclr DA 40 13 E6 2F ldaB 26 09 LD540 brclr DA 80 0B LD544 02 DA 3F bra LD54F ; LD549 03 DA 10 ldaA L9852 LD54F: pushA clrA LD551 brclr 78 80 0C LD555 brset 81 88 08 ;open/closed loop?/bit3 LD559: ldaB 45, X beq LD561 ldaA L9844 mul LD561: popB cBA bcc LD566 tBA LD566: call LE548 ;messes with L00FC ;Calculate fuel trim value ldaA LTFT ; LTFT brclr L0081,bit7,LD5B0 ;branch if open loop LD56F: ldaA L9860 ;A = $01 – fuel trim value brclr L0078,bit7,LD57A brclr L007A,bit1,LD592 ldaA L9861 ;A = $04 brclr L007B,bit4,LD592 LD581: ldaA L9862 ;A = $04 brclr L007B,bit5,LD592 LD588: ldaA L9863 ;A = $02 brclr L00D7,bits5-4,LD592 ;test bit4,5 L00D7 ldaA L9864 ;A = $04 ldaB L0074 ;previous O2 sensor reading cmpB L983C ; > 0.95V?? bcs LD59A ; positive trim negA ; negative trim LD59A: clrB ;clear B addD L00E9 ;D = L00E9,10 + D addD #$0080 ;D = (E9+AB+80) staA STFT ;STFT ldaB LTFT ;LTFT mul lslD addD #$0080 ; (LTFT*STFT)*2)+80 ldy L9867 ; Y = LD5AD: call LE5A0 ;check limits call LE53B ;calculates a value ->L00FC ; ldaA L006E ;ATS_Raw ldY #$F313 LD5B9: call LE5B0 ;compare A with limits in Y ldX #$929B ; table??? call LE520 call LE53B ldX #$9273 LD5C8 brclr L00D7, #$01,LD5CF ;test bit0 L00D7 ldX #$927B LD5CF brclr 81 88 07 ;L0081 open/closed loop/? LD5D3 brset 81 10 03 ;L0081 bit3 LD5D7: ldX #$9283 call LE4EA ;Table look up v WTS staA L011C LD5E0 brclr 81 88 33 ;L0081 open/closed loop? LD5E4 brset 81 10 2F ;L0081 bit4 LD5E8: ldaA L9846 LD5EB brclr 81 08 20 ;L0081 bit3 LD5EF: ldaA L985E LD5F2 brclr 7C 40 19 ldaA L985B ldaB L005C ;MAP/5 cmpB L985D bcc LD60F ;bra if MAP< ldaB Baro_x ;Baro Pressure subB L9834 bcc LD608 clrB LD608: cmpB L005C ;MAP/5 bls LD60F ldaA L985C LD60F: cmpA L011C bcc LD617 ldaA L011C LD617: call LE548 ; LD61A brset D7 01 08 ;test bit0 L00D7 LD61E: ldaA L0091 beq LD626 LD622 brset 81 08 05 ;L0081 bit3 LD626: ldaA L00F4 call LE548 ; LD62B brset 80 02 06 LD62F: ldaA L9877 call LE53B nop nop nop LD638 02 97 FB LD63B brclr D7 01 1A ;test bit0 L00D7 LD63F brset 78 20 16 LD643: ldX #$9326 call LE4EA ;Table look up v WTS ldaB L011D beq LD651 LD64E 03 97 04 LD651: mul ldaB L98A4 mul call LE552 ; LD659 brset D7 01 48 ;test bit0, L00D7 LD65D brset D7 38 1A ;test bit5,4,3, L00D7 LD661: ldaA L0091 bne LD67B ldaA L006C cmpA L98A0 bcc LD67B ldaA L015D beq LD67B LD671 brset 78 20 06 LD675: ldD L98A2 call LE552 ldaA L015B beq LD6A5 LD680 brset 78 80 21 brset 82 30 1D LD686: tSX cpD #$966F cmpA L9878 bcc LD6A5 ldaA L0091 beq LD6A5 ldaA L0144 beq LD6A5 ldX #$932E call LE4EA ;Table look up v WTS clrB lsrD lsrD lsrD call LE552 LD6A5: ldaA L9887 LD6A8 brclr D7 01 03 ;test bit0 L00D7 ldaA L9888 LD6AF brset DA 08 18 LD6B3 brclr D7 01 07 ;test bit0 L00D7 LD6B7: ldX #$92E4 LD6BA brset 81 08 0A ;L0081 bits3,0 LD6BE: ldX #$92D0 LD6C1 brclr 83 80 03 ldX #$92DA call LE4F0 ;Table look up v WTS staA L00F8 LD6CD brset 81 80 5E ;L0081 bit7 open/closed loop LD6D1: ldaA L00F9 bitA #%11100000 bne LD6DF lslA lslA lslA cmpA L987A bcs LD6E2 LD6DF: ldaA L987A LD6E2: cmpA L00F6 bcc LD6E8 ldaA L00F6 LD6E8: pushA ldX #$92C8 LD6EC brset DA 08 0A LD6F0: ldX #$92B8 LD6F3 brclr 83 80 03 ldX #$92C0 call LE4EA ;Table look up v WTS LD6FD brclr D7 01 0C ;test bit0 L00D7 LD701 brset DA 08 08 brclr 81 08 04 ;L0081 open/closed loop LD709: ldaB L9889 mul ldaB L9879 mul lsrD stD L00C1 popB call LE460 ;16 x 8 multiplication call LE552 ldX #$931E call LE4EA ;Table look up v WTS ldaB L9894 mul stD L00C1 ldaB L00FA call LE460 ;16 x 8 multiplication call LE55B LD72F brclr 78 10 15 ldaB L989E ldaA L015B beq LD73E ldaB L989F LD73E: ldaA L018A mul lsrD lsrD lsrD call LE552 ldX #$933E call LE506 ;table look up v batt volts ldaB L98A7 mul lslD tAB ldX L00FC call LE45E lslD bcc LD75F ldD #$FFFF LD75F: stD L00C3 ;L00C3 subD #$02D0 bcc LD768 clrA clrB LD768: lslD cmpA #$05 bcs LD770 ldD #$0500 LD770: ldX #$934E call LE525 clrA addD L00C3 ;L00C3 bcc LD77E ldD #$FFFF LD77E: stD L00C3 ;L00C3 ldX L98AA LD783 brset 81 10 0B ;L0081, bit4 LD787: ldX L98AC tst L012D beq LD792 ldX L98A8 LD792: cmpX L00C3 ;L00C3 bls LD79E xgdX LD797: stD L00C3 ;L00C3 oim L0097, bit1 ;L0097 bit 1 bra LD7A1 ; aim L0097, bits7-2,0 LD7A1: call LE568 ;correction for battery voltage stD L00FE ;injector pulse width (uS) ldX #$9300 LD7A9 brclr D7 01 03 ;test bit0 L00D7 - config ldX #$9308 ldaA L015B beq LD7BE LD7B5 brset C0 40 05 03 97 80 LD7BC: bra LD7EC ; LD7BE 02 97 7F LD7C1 brset D7 01 09 ;test bit0 L00D7 LD7C5: ldaA L0093 ;VSS cmpA L9886 bcs LD7D9 bra LD7D2 ; LD7CE brset 78 20 07 LD7D2: ldaA L006F ;TPS cmpA L9881 bcc LD7EC LD7D9: ldX #$92F8 LD7DC brset 78 10 0C LD7E0 brset D7 01 08 ;test bit0 L00D7 LD7E4: ldX #$92EE call LE4F0 ;Table look up v WTS bra LD7EF ; LD7EC: call LE4EA ;Table look up v WTS LD7EF brset D7 01 19 ;test bit0 L00D7 LD7F3: ldaB L008C LD7F5 26 11 bne LD808 LD7F7 brclr D7 20 11 ;test bit5 L00D7 ldaB L00F4 beq LD80C ldaB L018E bne LD80C LD804 brset E4 04 04 LD808: ldaB L9892 mul pushA ldX #$9310 call LE4FB ;Table look up v RPM popB mul stD L00C1 ldaB L98A7 call LE460 ;16 x 8 multiplication stD L00C3 ;L00C3 call LE568 ;correction for battery voltage stD L0100 ret ; ; ;SUBR10 - Ignition timing !!! SUBR10: ldX #$00B2 ldaB #$01 call LC4A9 ;;Unknown! ldY #$97B2 ;Y points to 97B2?? LD832: call LE5E1 ;get actual RPM? cmpB #$10 ; rpm >= 16 ?? bcc LD83A ; =BHS clrB LD83A: cmpB #$E0 bls LD840 ;bra if >= 224 ldaB #$F0 ; default RPM = 240 LD840: staB L00C6 ;RPM into X axis?? ldD L005C ;L005C,5D = MAP*51.5 brclr L0082,bit1-0, LD84B ;L0082 MAP? ldD #$FFFF ;AB = $FFFF ldY #$97D3 LD84F: call LE5E9 ;C1,2,3=AB*152?? cmpB #$10 bcc LD857 clrB LD857: cmpB #$B0 bls LD85D ldaB #$C0 LD85D: staB L00C7 ;C7 = MAP into Y-axis? ldX #$9390 ;X is pointer to table at L9390 ldy #$1040 ;Y is(16, 64?) LD866: call LE4A3 ;do table look up staA L0104 ;store in L0104 brclr L0081, bit6,LD8AE ;L0081, bit6 ldD L00C6 cmpA #$B0 bcs LD878 ldaA #$B0 LD878: subA #$60 bcc LD87D clrA LD87D: cmpB #$A0 bcs LD883 ldaB #$A0 LD883: subB #$50 bcc LD888 clrB LD888: stD L00C6 ;?? ldX #$9460 ;x is pointer to L9460 LD88D brclr D7 20 03 ;config?? ldX #$9DC0 ;X is pointer to table at L9DC0 ldY #$0600 ;table is 6,? LD898: call LE4A3 ;do table lookup brclr L00D7,bit5,LD8A6 ;config 5 is set!! ldaB L018C ;timing correction??? mul ;A*B lslD ;test msb bcc LD8A8 ldaA #$FF LD8A8: addA L0104 ;add to L0104 staA L0104 ;store on L0104 ldaA #$80 LD8B0 brclr 78 04 04 LD8B4 brclr 78 02 42 LD8B8 brclr 78 80 08 LD8BC brclr 81 10 04 ;L0081 bit4 LD8C0 brset 97 40 04 LD8C4 brclr 81 20 32 ;L0081 bit5 LD8C8: clrB ldaA L0052 ; RPM modified subA L004F ; RPM/8 bcc LD8D1 incB negA LD8D1: staB L00C1 ldaB L98DA D8D6 brclr D7 01 07 ;test bit0 L00D7 D8DA brset 78 20 03 LD8DE: ldaB L98D9 mul addD #$0020 bitA #%11000000 bne LD8F0 lslD lslD cmpA L98DB bls LD8F3 LD8F0: ldaA L98DB LD8F3: ldaB L00C1 beq LD8F8 negA LD8F8: addA #$80 staA L0106 ;L0106 ldX #$9484 ;Ignition advance v WTS call LE4F0 ;Table look up v WTS LD903 brclr 78 80 09 ldaA L006C cmpA L98DD bcs LD910 ldaB #$80 LD910: staB L0105 ldaA L0050 ;RPM manipulated ldaB #$4F mul call LE587 addD #$0080 staA L00B5 ldX #$0103 ;L0103 ldaB 1, X clrA xgdY LD928: ldaB #$80 ldaA TfStart ;Time from start addA L98DE ;test limit = (0-73) = 8D bcc LD945 ldaA L015B bne LD945 LD936 brset 81 08 0B ;L0081, bits3,1-0 brset 78 80 07 brclr 7A 02 03 LD942: ldaB L98DF abY LD947: ldaB 2, X abY ldaB 3, x abY xgDY LD951: bset 2, X, #%01001110 bls LD959 ldD #$024E LD959: bset 1, X, #%11001110 bcc LD961 ldD #$01CE LD961: subD #$0180 staB 0, X ldaA #$EE sBA staA L00B0 ldaA L0058 ; get Batt_Raw subA #$80 ; Batt_Raw - 9.44V bcc LD972 ; bra if batt OK clrA LD972: pushA ldX #$948E ; ignition dwell time v WTS call LE520 staB IgnDwel ; dwell angle ??? popA ldX #$9366 ; ignition??? call LE520 staB L015F ; timing value??? ret ; ; ; ;SUBR11 - Fuelling?? SUBR11: ldX #$0100 ldaA Baro_x ;Baro Pressure ldY #$BD7D LD98F: call LE5B0 ;compare A with limits in Y subA #$40 negA ldaB L98E1 mul staA 16, X ldaA L0081 ;L0081 andA #%00000011 ;isolate bits 0,1 L0081 bne LD9C5 ;if either bit set bra ldaA #$04 LD9A3 brset L0082 06 1E ;L0082 bits4-1 TPS, MAP LD9A7: ldaA #$08 LD9A9 brset D2 01 18 LD9AD 86 08 brset D2 01 18 LD9B3: andB #%00011110 cmpB #$02 bra LD9BD ; andB #$3E cmpB #$22 LD9BD: bne LD9C3 LD9BF brset 7D 10 02 LD9C3: ldaA #$10 ldaB L00B7 ;L00B7 staA L00B7 ;L00B7? LD9C9 02 B8 7F bitB #$02 beq LD9D7 bitA #%00010000 beq LD9D7 LD9D4 03 B8 80 bitB #$08 LD9D9 26 09 bne LD9E4 LD9DB brclr B7 08 05 ;L00B7 ldD #$5000 bra LD9F2 ; LD9E4: bitB #%00010000 bne LD9F5 LD9E8 brclr B7 10 09 ;L00B7 LD9EC 03 B9 07 LD9EF: call LE450 call LE436 ; LD9F5 brset C0 10 0C LD9F9: ldaA TfStart ;Time from start addA L98E3 ;test limit = (0-FF)=1 bcc LDA05 LDA00 03 83 10 20 13 brclr 83 10 0F LDA09 brset 78 10 0B 02 83 EF LDA10: call LE450 stD 9, X LDA15 03 B9 04 ldaB #$B8 brclr B8 80 03 LDA1E 03 B8 40 brclr 78 04 04 LDA25 brclr 78 02 16 LDA29 brclr B7 10 12 ;L00B7 ldaA 84, X addA L98E8 bcs LDA4C ldaA L0051 ; get RPM cmpA L98E9 ; RPM - 217 bcc LDA3F LDA3B brset 78 80 0D LDA3F: aim L00B8, #$BF LDA42: bitB #%01000000 beq LDA4C ldaA 15, X subA 19, X bcc LDA4D LDA4C: clrA LDA4D: staA L018F LDA50 brclr B6 10 0D ldaB L98F7 LDA57 brset 78 10 03 LDA5B: ldaB L98F8 call LE42F LDA61 brclr B6 08 06 ldaB L98F9 call LE42F LDA6B brclr D7 01 11 ;test bit0 L00D7 LDA6F brclr B6 20 0D ldaB L98FA LDA76 brclr 78 20 03 ldaB L98FB call LE42F ldaB L98EC LDA83 brclr 78 80 08 LDA87 brset 2F 08 04 ;throttle opener brset B7 18 02 ;L00B7 LDA8F: staB 52, X ldaA 97, X beq LDAAE ldaB L0091 bne LDAAE LDA99 brclr 94 08 11 decA cmpA #$F9 bcc LDAAC ldaB 98, X addB #$02 bcc LDAAA ldaB #$FF LDAAA: staB 98, X LDAAC: staA 97, X LDAAE: ldaB L98EE LDAB1 brclr B7 08 03 ;L00B7 ldaB L98EF LDAB8 brclr B9 20 0B ldaA #$FF staA 97, X ldaA L98ED staA 98, X bra LDAD1 ; LDAC7: ldaA 53, X ; L0153 beq LDAD3 ; now do target idle ldaA L0050 ; RPM/32? cmpA 98, X ; (RPM/32)-L0198 bcs LDAD3 ; now do target idle staB 53, X ; L0153 = RPM/32 ; ; Target Idle get value from table at 95F1, use this or value set by scan tool or load a default value ; instead, Tech1 manual says idle switch must be closed VSS = 0, WTS OK ; LDAD3: ldX #$95F1 ; target idle? call LE4EA ;Table look up v WTS brclr L00B7,bit3,LDAF5 ; don’t set target idle from scan tool ldaB L98FC ; 816rpm brclr L00D2,bit0,LDB10 ; serial port status??? ldaB L0164 ; Actuators byte 2 cmpB #$40 ; idle lower limit = bcc LDAED ; OK test against upper limit ldaB #$40 ; limit to 40? LDAED: cmpB #$E6 ; idle upper limit bls LDAF3 ; OK carry on ldaB #$E6 ; limit to E6? LDAF3: bra LDB10 ; store this as target idle value ; LDAF5: ldaB L98FD ; 1024rpm LDAF8 brclr D7 01 04 LDAFC brclr 78 20 0B LDAFE brset 78 10 08 ldaB L98FE ; 976rpm LDB07 brset B8 40 01 LDB0B: tAB cBA bcs LDB10 tAB ; LDB10: staB L00D5 ; store target Idle ldX #$94B9 LDB15 brset D2 01 0B LDB19 brset B7 08 1E ;L00B7 brclr 83 10 03 LDB21: ldX #$94C1 LDB24 brclr D7 01 08 ; test bit0 L00D7 LDB28 brset 78 20 04 LDB2C: incX incX incX incX LDB30 brclr 78 10 02 incX incX LDB36 brclr 78 08 01 incX ldaB 0, X ldX #$0100 staB 13, X LDB42 brclr B7 18 4B ; L00B7 LDB46 brset 82 30 4D LDB4A: ldaA 40, X bne LDB97 LDB4E brclr 94 02 49 ;L0094 clrA clrB LDB54 brset 78 80 0F LDB58: ldaA L006F ;TPS cmpA #$20 bcs LDB60 ldaA #$20 LDB60: ldX #$9497 call LE51A clrB ldX #$0100 stD L00C1 brset 17, X, #%00100011, LDB80 ldD 17, X addD L9901 bcc LDB7A ldD #$FFFF cpD LC125 cBA bra LDB8D ; LDB80: ldD 17, X subD L9903 bcc LDB89 clrA clrB cpD LC124 LDB8C 02 DC C1 bra LDB99 ; LDB91: ldD #$5000 call LE436 clrA clrB stD 17, X LDB9B 02 B8 CF brset 78 10 17 LDBA2 brclr D7 01 04 LDBA6 brclr 78 20 0F LDBAA brclr B8 40 0B LDBAE 03 B8 10 A6 13 ldaA A1 0F cmpA 24 06 bcc bra LDBC0 ; LDBB9: ldaA 19, X beq LDBC0 LDBBD 03 B8 20 D6 B9 ldaB 02 B9 3F ldaA 52, X bne LDBE5 ldaA L0091 bne LDBE5 LDBCD brset B9 20 14 LDBD1 brset B8 20 0A LDBD5: ldaA 88, X bne LDBDF ldaA 53, X beq LDBE2 bra LDBE5 ; LDBDF 03 B9 40 03 B9 80 brclr B7 10 2D ; L00B7 bitB #%10000000 beq LDC16 ; LDBED brset B9 80 25 LDBF1: ldX #$0107 LDBF4 brset B9 02 06 LDBF8: call LE43D LDBFB 03 B9 02 incX incX LDC00 brset B9 04 06 LDC04: call LE43D LDC07 03 B9 04 incX incX LDC0C brset B9 01 06 LDC10: call LE43D LDC13 03 B9 01 brset 78 08 0D ldD L0107 LDC1D brclr 78 10 03 ldD L0109 stD L010B LDC27 brset B7 08 0E ;L00B7 LDC2B: ldX #$010B LDC2E brset 78 08 0A LDC32 CE 01 09 brset 78 10 03 CE 01 07 LDC3C: ldD 0, X addA L018F bcs LDC48 cmpA L98FF bcs LDC4C LDC48: ldaA L98FF clrB LDC4C: stD L00C3 ;L00C3 stD 0, X LDC50 brclr B9 80 3C ldaA L0132 bne LDC93 LDC59 03 B9 08 LDC5C: ldaA L00D5 ;target Idle subA L0051 bcc LDC66 negA LDC63 02 B9 F7 clrB LDC67 brclr B7 08 04 ;L00B7 LDC6B brclr D2 01 03 ldaB L98F0 ;$05 cBA bhi LDC96 cmpX #$0107 bne LDC7D LDC7A 02 B9 FD cmpX #$0109 bne LDC85 LDC82 02 B9 FB cmpX #$0109 bne LDC8D LDC8A 02 B9 FE jmp LDD35 clr L0132 jmp LDD3B ; LDC96 brclr B7 08 0C ;L00B7 LDC9A brset D2 01 08 LDC9E: cmpA #$0D bcs LDCA4 ldaA #$0D LDCA4: bra LDCAC ; LDCA6: cmpA #$20 bcs LDCAC ldaA #$20 LDCAC: ldaB L993D ;$0A tst L0158 bne LDCB7 ldaB L98F2 ;$14 LDCB7 brclr B7 08 0A ;L00B7 ldaB L98F3 ;$28 LDCBE brclr D2 01 03 ldaB L98F4 ;$0D tst L0133 beq LDCCD ldaB L98F5 ;$02 LDCCD: mul lsrD LDCCF brclr B9 10 04 ldaA L98F6 ;$05 clrB stD L00C1 ldD L00C3 ;L00C3 LDCDB brset B9 08 0F LDCDF: subD L00C1 bcs LDCE8 cmpA L9900 bcc LDCEC LDCE8: ldaA L9900 clrB LDCEC: bra LDD08 ; LDCEE brclr D2 01 09 LDCF2: addD L00C1 bcc LDCF9 ldD #$FFFF LDCF9: bra LDD08 ; LDCFB: addD L00C1 bcs LDD04 cmpA L98FF bcs LDD08 LDD04: ldaA L98FF clrB LDD08 brclr B7 08 04 ;L00B7 LDD0C brclr D2 01 21 brset B9 40 04 LDD14 brclr 44 40 19 brclr L0044, bits4,3,0 ;test TPS and O2 sensor stD L00C1 clrB ldaA L98EA addA L0110 bcs LDD28 cmpA L98FF bcs LDD2B LDD28: ldaA L98FF cpD LC125 LDD2E 02 DC C1 aim stD L00C3 ;L00C3 stD 0, X ldaA L98F1 staA L0132 pushX ldX #$0100 ;X=100 LDD3F brclr B8 80 0C ldaA L98E4 ;A = 28 staA 14, X staA 19, X ldaA L98E7 staA 15, X LDD4F brclr B7 10 2D ;L00B7 LDD53 brset 2F 08 31 ;throttle opener? LDD57: ldaA 84, X addA L98E6 bcs LDD88 ldaA 49, X bne LDD6E ldaB L98E5 staB 49, X ldaA 19, X beq LDD6E decA staA 19, X LDD6E: ldaA 19, X LDD70 brset B8 10 02 LDD74: clr 15, X cmpA 15, X bcc LDD7C ldaA 15, X LDD7C: staA 14, X bra LDD88 ; LDD80: clr 14, X clr 19, X clr 49, X clr 15, X popX LDD89 02 B9 CF LDD8B CF 4F 5F ?? mystery opcode LDD8C brset B7 01 78 ;L00B7 LDD92 ldaA #$FF LDD94 brset B7 02 72 ;L00B7 LDD98: ldaA L9905 LDD9B brclr 78 10 03 ldaA L9906 LDDA2 brset B7 04 64 ;L00B7 LDDA6: clrB ldaA L0110 LDDAA brset B7 08 03 ;L00B7 LDDAE: ldaA L010E addA L010D bcc LDDB9 ldD #$FFFF LDDB9: stD L00C1 addD L00C3 ;L00C3 rol >L00C5 subA #$50 bcc LDDD7 LDDC4 brset C5 01 22 LDDC8: ldD #$5000 subD L00C1 bcc LDDD1 clrA clrB LDDD1: stD 0, X clrA clrB bra LDDEA ; LDDD7 brclr C5 01 0F LDDDB: ldD #$4FFF subD L00C1 bcs LDDE5 ldD #$FFFF LDDE5: stD 0, X ldD #$FFFF brclr 1, X, #%00010001, LDE10 di ldX L0111 beq LDDFE LDDF4 03 B9 20 brset B7 08 03 ;L00B7 ldD L0111 LDDFE: cmpA L98E0 bcc L0024,bits2,1,0, LDE0A ldaA L98E0 clrB oim L00B9, bit7 stD L00BA ;IAC Flow l/min B6 01 25 ldaA addA #$03 bcs LDE4A ldD L00BA ;IAC Flow ldX #$94A0 ;00 call LE521 clrA lslD lslD lslD stD L00C4 ldX L00BA ;IAC Flow ldaB L9909 ;09 call LE45E ;16 x 8 multiplication addD L00C4 bcs LDE32 addD L9907 ;+03 bcc LDE35 LDE32: ldD #$FFFF LDE35: stD L00C3 ;L00C3 ldX #$94B1 ;X = 00FF/FFFF call LE506 ;table look up v batt volts ldX L00C3 ;L00C3 call LE45E lslD bcs LDE4A cpD #$1388 bcs LDE4D LDE4A: ldD #$1388 LDE4D: stD L00BC subD #$007D stD L0238 ret ;*********************************************************************************** ; ; SUBR12 ; ;*********************************************************************************** ; SUBR12: ldX #$0100 ;set up pointer to start of extended RAM ldaA LTFT ;LTFT ldaB STFT ;STFT mul ;LTFT * STFT lslD ;convert to 8-bit addD #$0080 staA TFT ;Store as TFT ldaA LTFT ;LTFT ldaB L00E8 mul ;LTFT * L00E8 lslD addD #$0080 staA L00F5 ;something based on LTFT ldaA L98C9 ;$32 ldaB 7, X ;B = L0107 cmpB #$96 bcc LDE8A ; clrA cmpB #$0A bcs LDE8A subB #$0A ldaA #$EA mul addD #$0080 ldaB L98C9 ;$32 mul lslD LDE8A brclr B7 08 08 LDE8E brset D2 01 04 brset B9 80 4B LDE96: ldaB L0078 ;test bits2-1 andB #%00000110 cmpB #$06 bne LDEE0 ldaA L98C9 ;$32 lsrA ;=$64 LDEA2 brclr 81 10 3B ;L0081 bit4 LDEA6: ldaB L00F5 ldaA #$A0 sBA bcc LDEAE clrA LDEAE: cmpA #$40 bls LDEB4 ldaA #$40 LDEB4: ldaB L98C9 ;$32 mul lslD lslD addD #$0080 ldaB 54, X ;L0154 to do with ISC? bne LDEC7 ldaB L98CB lslB staB 54, X ;??? LDEC7: cmpB L98CB bls LDEDB addA L98CA bcs LDED6 cmpA L98C9 bls LDEE1 LDED6: ldaA L98C9 bra LDEE1 LDEDB: subA L98CA bcc LDEE1 clrA LDEE1: staA IACMon ;IAC Adjust Monitor clrA clrB stD L00C3 ;L00C3 ldaB 42, X bne LDEF6 LDEEB brclr 06 40 07 ldaB 37, X addB L98AE ;$78 bcc LDEF9 LDEF6 03 C4 04 LDEF9 brset 78 80 18 brclr 7C 20 14 brclr 7A 80 10 brclr 7E 04 0C LDF09: ldaA L0091 beq LDF15 LDF0D 03 C4 01 LDF10 03 32 02 bra LDF18 ; LDF15 02 32 FD 02 32 FE brclr D7 20 7D LDF1F: ldX L00C3 ;L00C3 pushX clrB staB L018D LDF26 02 B8 F7 brclr E5 80 5F LDF2D brclr 81 40 5B ; L0081, bit6 LDF31: ldX #$0100 ;X = 100 LDF34 CF 6D 01 0C LDF38 CF 6E 01 50 LDF3C: ldaB L993E ;B = $1E LDF3F 03 B8 08 bra LDF8C LDF44 03 B8 08 ldX #$95E3 LDF4A brclr C0 80 03 LDF4E ldX #$95D9 ldy #$9470 LDF55: ldaA L006D ;WTS modified call LE5B0 ;compare A with limits in Y call LE51A pushA LDF5E CD CE 97 AA LDF62: call LE5E1 staB L00C6 ldY #$97CB LDF6B: call LE5E7 staB L00C7 ldY #$1000 Y is pointer to L1000 LDF74: ldX #$9600 ;X is pointer to L9600 call LE4A3 ;do table lookup staA L018D popB mul lslD tAB subA L0169 bcc LDF87 negA LDF87: cmpA L992D bls LDF8F staB L0169 ;=$00 LDF8F: popX stX L00C3 ;L00C3 ldX #$0100 LDF95 brclr 81 01 14 ;L0081, bit0 bra LE087 LDF9C 02 46 BF ‘test fault flags ****** LDFA0: bpl LDFC8 LDFA2 03 7E E0 PORT2 brset 87 81 40 03 03 C3 01 ; CHECK BINARY!!!!! LDFAC brclr 7D 20 17 brset 82 30 13 ; L0082 TPS brclr 7F 20 0F LDFB9 brset 7F 40 0B brclr 80 10 07 brset 78 01 03 03 C4 10 ; L00C4-> status reg? LDFC8: ldaA L0093 ; VSS cmpA L98B4 bcc LDFE4 cmpA L98B5 bcc LDFE7 LDFD4 02 DE FB clrA LDFD8 brclr D7 30 03 ldaA L98B6 staA L014E bra LDFE7 ; LDFE4 03 DE 04 LDFE7 brclr 81 02 09 ; L0081 bit1 ldX #$94C9 call LE4EA ; Table look up v WTS staA L0120 ldaA TfStart ; Time from start addA L0120 ; add ? bcs LE029 ldaA L0058 ; get Batt_Raw cmpA L98B3 ; Batt_Raw – 16.6V bcc LE029 ; bra if batt high LE002 brclr DE 04 05 ldaA L014E beq LE029 LE00B brset 81 03 1A ; L0081 bits1-0 LE00F: ldaA TfStart ; Time from start addA L98B2 ; test limit = (0-2)=FD bcs LE026 LE016 brset 81 08 0F brset L0081,#$08 , L**** ;L0081 bit3-1 LE01A brclr D7 30 04 brclr L00D7, bit5&4 ;test config setting LE01E brset 7C 40 07 LE022 brset DC 80 03 oim L00C3, bit5 ;L00C3 bit5 -> status reg? aim L00DA, bit0 ldX #$935C call LE4F0 ;Table look up v WTS LE032 brclr 82 40 01 clrA ldX #$0100 LE03A brclr 81 02 04 ;L0081 bit1 staA 94, X bra LE061 LE042: cmpA 94, X bcc LE048 staA 94, X LE048: ldaA 94, X beq LE067 LE04C: brclr 94 04 0D ;L0094 bra LE05D? ldX #$9354 ;9354 = 30h call LE4EA ;Table look up v WTS cmpA L0050 ;RPM manipulated ?? bhi LE05D dec L015E ;L015E = TO count?? LE05D brset 7B 40 06 LE061 oim L00C4, #$08 ;L00C4 -> status reg - throttle opener???? LE064 03 DA 01 LE067 brclr D7 01 1C brset 82 40 18 brset C0 20 14 LE073 brset 80 40 10 brset 97 10 0C brset 78 20 08 LE07F: ldaA L0137 bne LE087 oim L00C4, bit3 ;L00C3-> throttle opener?? LE087: di ;read port7 and isolate Diag_out_term and duty_out_term ( bits4-2 are n/c) ; ldaA P7DDR ;read PORT, 7 LE08A brset D7 20 12 brset, L00D7, bit5, LE0A0 ;skip next bit (config) LE08E: andA #%11011100 ;clear EGR bits oraA L00C3 ;set EGR bits and diag???????? xorA #%00000001 ;check for bit0 toggled (EGR) clrB bitA #%00000001 check for bit0 polarity (EGR) beq LE09B ;bra if 0 ldaB #$08 LE09B: staB L0188 ;Status Flags 1 – EGR status = ? bra LE0B3 ; LE0A0: andA #%11011111 ;isolate bit 5 oraA L00C3 ;set EGR bits and diag????? ldaB #$08 ;B = $08 LE0A6 brclr B8 08 06 ;skip to clear EGR status tst L016A ;test L016A beq LE0B0 clrB LE0B0: staB L0188 ;Clear EGR status bit staA PORT7 ;write PORT7 ldaA PORT6 ;read PORT6 - andA #%00100011 ;clear bits oraA L00C4 ;set bits from L00C4 staA PORT6 ;store to PORT6 ei ldaA L00C4 staA L0186 ;Status Flags 2 clr L01brset ret ; ;*********************************************************************************** ; ;SUBR13 - Set/clear fault flags ; ; SUBR13: ldaA L0044 ; get Fault codes 0 ldaB L0046 ; and Fault Codes 1 stD L00C3 ; copy to RAM ldaA L0048 ; immo status? staA L00C5 ; copy to RAM brclr L0081, bit1,0 LE0E2? ; check flag? – L0081 is internal fault flags? ldX #$9929 ; X = $53 ldaB L007D lslB ; left shift B ldaA L006C ;load A with L006C call LE61A ;test bit result in B? staB L007D ;C3 ldX #$0100 brclr L0078, bit7, LE0EE aim L00C4, #EF ;clear bit7 L00C4 bra LE101 ; LE0EE 87 81 03 0F ;L0081 bit1-0 LE0F2: ldaA L0050 ;RPM/32 cmpA L98BE ;A - $20 bcc LE101 ;bra if RPM>1024? LE0F9 brclr D7 01 08 LE0FD brset 78 20 04 LE101: ldaB #$64 staB 75, X ;L0175 = $64 ldaB 75, X ;get L0175 bne LE10C LE109 03 C4 10 ;L00C4 LE10C brset 78 80 05 ;L0078 LE10F 02 C4 DF ;L00C4 LE112 bra LE136 LE114 brset 81 02 1E ;L0081 bit1 LE119: ldaA L0050 ; RPM/32 cmpA L98C0 ;5D = 2976rpm bcs LE12B ;bra if <2976rpm LE120 brset 82 06 07 LE124: ldaA L005C ; MAP/5 cmpA L98C1 ;MAP -$56 bcc LE13B ;bra if MAP>$6 di ldaA L005B ; TPS Volts brset L0082, bit7, LE137 ;L0082, ATS LE132: cmpA L98BF ; TPS_Raw - $3D bcc LE13B ldaB #$32 staB 76, X ;store L0176 LE13B: ei ldaB 76, X ;fetch L0176 bne LE143 oim L00C4, #$20 ;set L00C4, bit5, idle sw fail LE143 brclr 83 01 08 LE147 02 83 FE aim L00C4, #$F7 ;clr L00C4 bit4 bra LE153 ; LE14F brset 79 40 05 LE153: ldaB L98C2 ;B = $78 staB 62, X ;L0162 = 78 ldaB 62, X ;get L0162 bne LE15F oim L00C4, #$08 LE15F brset 82 40 05 brset L0082, #$40 ;bra if WTS OK? aim L00C3, #$F9 ;clr L00C3 bit2,1 bra LE16C LE168 brclr 81 03 04 ;L0081 bits1-0 LE16C: ldaB #$32 staB 71, X ;Store L0171 ldaB 71, X ;Fetch L0171 bne LE18B ;test for zero ldaA L0054 ;Get WTS_Raw comA ;$FF - WTS cmpA #$12 ;compare bcs LE184 ;bra less than $12 LE17B brset C3 02 E4 ;L00C3 03 C3 04 ;L00C3 LE182: bra LE18B LE184 brset C3 04 DB ;L00C3 03 C3 02 ;L00C3 LE18B brset 82 80 05 ;L0082 ATS? 02 C3 5F ;L00C3 20 04 brclr 81 03 04 ;L0081 bit1-0 LE198: ldaB #$32 staB 74, X ldaB 74, X bne LE1B7 ldaA L0055 ;get ATS_Raw comA cmpA #$15 bcs LE1B0 LE1A7 brset C3 20 E4 ;L00C3 03 C3 80 ;L00C3 bra LE1B7 LE1B0 brset C3 80 DB ;L00C3 03 C3 20 LE1B7: di ldaA L0059 ; get MAP_Raw brset L0082, bit0, LE1C4 ; MAP LE1BE: ei aim L00C4, $FC ;clear bit1,0 L00C4 bra LE1DF ; LE1C4: ei LE1C5 brset 81 03 16 ;L0081 bit1-0 LE1C9: cmpA #$E8 bhi LE1E3 ldaB L0050 ;RPM manipulated cmpB L98BC bcs LE1E3 LE1D4 brset 82 30 07 LE1D8: ldaB L006F ;TPS cmpB L98BD ;lower limit = 0Ch? bcc LE1E3 ldaB #$32 staB 73, X LE1E3: ldaB 73, X bne LE1F7 LE1E7 brset C4 03 0C LE1EB: cmpA #$E8 bhi LE1F4 LE1EF 03 C4 02 andB #%00000010 bra LE1F7 ; andB #%00000001 LE1F7: di ldaA L005B ; get TPS Volts LE1FA brset L0082, bit7, LE204 ;ATS LE1FE: ei aim L00C3, bit3 ;L00C3 bra LE209 ei brclr L0081, Bits1&0, LE20D ldaB #$32 staB 72, X ;X++? ldaB 72, X bne LE221 LE211 brset C3 18 0C brset L00C3, bits4|3 ;L00C3 LE215: cmpA #$F8 bhi LE21E oim L00C3, bit4 bra LE221 oim L00C3, bit3 ;L00C3 brclr L0081, bits1&0, LE22A ;L0081 oim L00C0, bit2 bra LE244 ; LE22A brclr 95 04 03 ;L0095 bit 2 sets 02 C0 FB ;L00C0 bits 7,6 brset 81 80 0F ;open/closed loop brclr 81 10 0B ;L0081 bit4 LE239: ldaA 86, X ;Load L186? bne LE244 LE23D brset 95 02 03 ;L0095 03 C0 04 LE244 brclr 95 40 07 ;L0095 LE248 brset 7A 02 03 03 C0 08 brset 81 07 19 ;L0081 bit2-0 brset 82 C6 15 ;L0082 ATS, MAP LE257: ldaA L006C cmpA L98BB bcs LE26C ldaA L0050 ;RPM manipulated cmpA L98B9 bcs LE26C ldaA L005C ;MAP/5 cmpA L98BA ;98BA = $5E bcc LE273 ;MAP - $5E LE26C: ldaA L98B7 ;L98B7 = $0F staA 89, X ; bra LE296 ; LE273: ldaA 89, X LE275 26 1F bne LE296 LE277 brclr C0 04 1B LE27B brclr C0 08 17 LE27F 02 C0 F7 brset C0 02 10 03 C0 02 LE289: ldaA L0200 ;A = L0200 beq LE293 ;if zero dec L0200 bne LE296 ;if = 1? oim L00C3, #$01 ;set L00C3, bit0 LE296 brset C0 04 09 ldaA L98B8 staA L0200 aim L00C3, #$FE ;clr L00C3, bit0 aim L00C4, #$7F ;clr L00C3, bit7 ldaA L0091 beq LE2AF aim L00C3, #$BF ;clr L00C3, bit6 bra LE2B3 ; ; Set/Clear fault codes ; ; brset L0081, bit2, LE2B7 ;L0081 bit2 LE2B3: ldaA #$32 staA 77, X ldaA 77, X bne LE2BE oim L00C3, bit 6 ;set L00C3 bit6 aim L00C4, #FB ;clr L00C4 bit2 brset L00D7, bit5, LE2CF brclr L00B3, bits2,1 LE2CF aim L00B3, bit5 oim L00C4, bit2 ;L00C4 LE2CF: ldaA L00C5 ;C5-> L0048 staA L0048 ldaA L00C3 ; brclr L0078, bit2, LE2DB andA L0044 ;clear fault code staA L0044 ;and store ldaA L00C4 ; L00C4 LE2DF brclr 78 04 02 brclr L0078, bit3 andA L0046 staA L0046 ;C4 to L0046 ldaA L0044 oraA #%11111111 ;set all bits andA L0045 oraA L0044 ;L0044 staA L0045 ldaA L0046 oraA #%11100111 andA L0047 oraA L0046 staA L0047 ;L0047 ; LE2FB: brset 78 04 04 brset 78 02 40 LE303: clr 21, X clr 22, X ldaA #$01 staA 23, X LE30B brclr 78 04 04 clr 61, X bra LE35F ; LE313 brclr 4B 80 13 LE317: ldaA 61, X bne LE327 ldaA #$14 staA 61, X di ldaA PORT7 ;Read PORT 31 xorA #%10000000 ;Toggle bit7 (CEL) staA PORT7 ;Write CEL ei LE327: jmp LE3DD ; LE32A: clr 61, X LE32C brclr 7A 01 10 LE330 brclr 7D 80 04 LE334 brset 46 03 08 ;brset brset 44 FF 04 brset L0044, all, LE340 ;L0044 any bits set? brclr 46 E4 1F brclr L0046, bits7-5,3 ;L0044 all bits clr? LE340: jmp LE3DA ; LE343: ldaA 61, X bne LE362 brset PORT7, bit7, LE364 ;test CEL LE34B: ldaA #$78 ldaB 21, X cmpB #$01 beq LE35D ldaA #$28 andB #%11110000 ;check against bit timing?? cmpB #$10 beq LE35D ldaA #$0C LE35D: staA 61, X oim PORT7, bit7 ;set/clr CEL?? bra LE3DD ldaA 15, X bitA #%11110000 beq LE36E subA #$10 bra LE373 ; LE36E: bitA #%00001111 beq LE373 decA LE373: staA 21, X bne LE3D5 dec 23, X bne LE3C8 ldaA L0045 bne LE38F ldaA L0047 bne LE38F ldaA L0048 ;load L0048 bne LE38F ;if not zero jump clr 22, X ;else clear 22, X ldaA #$01 staA 23, X ;and store $01 in 23,X bra LE3C8 ;jump to E3C8 ; LE38F: ldaA #$03 staA 23, X ldaB 22, X ;X = ?????? cmpB #$08 bcs LE3A3 cmpB #$10 bcs LE3AA cmpB #$18 ;18?????? bcs LE3B2 clr 22, X LE3A3: clrB ldaA L0045 callr LE3DE bcs LE3C8 LE3AA: ldaB #$08 ldaA L0047 callr LE3DE bcs LE3C8 LE3B2: ldaB #$10 ldaA L0048 callr LE3DE bcs LE3C8 clr 22, X ldaA L0045 bne LE3A3 ldaA L0047 bne LE3A3 ldaA L0048 bne LE3A3 LE3C8: ldaB 22, X ldX #$9700 aBX ldaA 0, X staA L0115 beq LE3DD LE3D5: ldaA #$0C staA L013D aim PORT7, #$7F ;clr CEL?? ret ; ; LE3DE: cmpB bcc LE3E6 incB lsrA bra LE3DE ; LE3E6: incB lsrA bcc LE3EE staB 22, X bra LE3F0 ; LE3EE: bne LE3E6 LE3F0: ret ; ; ; SUBR14: Part of serial link handler? ;Only executes code if L00D2 bit7 is clear ; SUBR14: brset, L00D2, bit7, LE422 LE3F5: ldaA L022C cmpA #$0A bcs LE422 ldX #$022D ldaB 0, X LE401 CD CE 00 00 LE405 CD 3A abY LE407: ldaA 128, X staA 0, X incX cmpX #$0231 bcs LE3FF LE411: ldX 0, Y ldD 128, X stD 0, X incX incX cmpX #$0235 bcs LE411 clr L022C ret ; LE423: di clrA clrB staA L00F1 stD L00EF LE42A 02 97 FE ei ret ; LE42F: cmpB 51, X bcs LE435 staB 51, X LE435: ret ; LE437: tPA stD 9, X stD 11, X ret ; LE43D: ldD 0, X addA L98EB bcs LE449 cmpA L98FF bcs LE44D LE449: ldaA L98FF clrB LE44D: stD 0, X ret ; LE450: clrB ldaA L98EA addA 16, X bcc LE45B ldD #$FFFF LE45B: ret ; ; LE45C: ldX L00C6 ; L00C6*B ; LE45E: stX L00C1 ; X*B ; ; 16-bit by 8-bit multiplication?? ; call with 8-bit number in B, 16-bit in C1,C2 ; 24-bit answer in C1,2,3 LE460: pushB ldaA L00C2 mul stD L00C2 ldaA L00C1 popB mul addB L00C2 adcA #$00 stD L00C1 ret ; ; 960000 divided by C4,C5 (calculate RPM) ; LE471: stD L00C4 ; D->denominatorL00C4,C5 = AB ldD #$A600 ; numerator = $A600 stD L00C2 ldD #$000E ; numerator = $0EA600 = 960000 bra LE480 ; LE47D: clr L00C3 ; clear L00C3 LE480: cpD #$C425 ; 0E = C425? lslD ldD #$FFFF ; D = $FFFF bra LE4A2 ; return ; ldY RMCR LE48D: ldX L00C2 xgdX ;multiply X by 2 aslD xgdX LE492: rolB rolA ;multiply AB by 2 bcs LE49A cpD #$C425 oim L0093,#$C4 ;VSS set bits7,6,2??? incX ;return C2 + 1 deY LE49F: bne LE48F xgdX LE4A2: ret ; ;table look up – interpolation algorithm ;table base value is in X, pointer is in Y LE4A3: ldD L00C6 ;load A and B from LC006/7 stY ;back up Y in L00C3 LE4A8: staA L00C5 ;store A in L00C5 clrA ;clear A but not B lslD lslD lslD lslD ;move top 4 bits of B into A pushB ;move B/8 onto stack ldaB L00C3 ;Load B with L00C3 mul ;A*B stX L00C1 ;save map location in LC001 addD L00C1 ;add result of multiplication stD L00C1 ;store result in LC001 ldX L00C1 ;Load index pointer with result pushX ;save on stack ldaB L00C3 ;Load B with B/8 aBX ;add B to index reg X callr LE4CE ;call LE4EC staB L00C3 popX callr LE4CE staB L00C2 popA ldX #$00C2 bra LE529 ;table look up??? LE4CE: ldaA L00C5 ;load A with original A (line E4A8) clrB ;clear B lsrD ;A(3..0) to B(7..4) lsrD lsrD lsrD pushB ;save B on stack tAB ;AccA -> AccB popA ;old B (Line E4D5) into A aBX ;add B to index reg X ldaB 0, X ;Load B with reg pointed to by X addB L00C4 ;add L00C4 to B result in C4 staB L00C1 ;store B in C1 ldaB 1, X ;B = Location X+1 addB L00C4 ;add B to LC004 also staB L00C2 ;store B in C2 ldX #$00C1 ;X = L00C1 bra LE529 ; ;Table look up v WTS ; LE4EA: ldY #$A030 ;load limits bra LE4F4 ;Table look up v WTS – alternative limits LE4F0: ldY #$C030 ;load limits LE4F4: ldaA L006D ;get WTS call LE5B0 ;compare A with limits in Y bra LE520 ;do table look up ; ;Table look up v RPM ; LE4FB: ldaA L0050 ;RPM/32 ldY #$E010 ;set limits LE501: call LE5B0 ;compare A with limits in Y bra LE520 ;do table look up ; ;a correction for battery voltage??? LE506: ldaA L0058 ;get Batt_Raw cmpA #$37 ;Batt_Raw – 4.055 bcc LE50E ;bra if Batt good ldaA #$BF ldY #$F637 LE512: call LE5B0 ;compare A with limits in Y ldaB #$96 mul bra LE521 LE51A: clrB bra LE523 clrB bra LE522 ;table look up LE520: clrB ;LE520 ; LE521: lsrD lsrD lsrD lsrD pushB tAB ;D = AA popA aBX ;Acc B to X LE529: tstA ;Test A beq LE537 ;if 0 goto LE537 ldaB 1, X subB 0, X bcc LE535 incX negB ;2s comp B negA ;2s comp A LE535: mul ;D = A*B lslB ;B=B*2 LE537: adcA 0, X ;add A and carry to index X tAB ;AB = AA ret ; ;;related to fuel trim LE53B: tAB ldX L00FC call LE45E ;X*B, answer in C1,C2,C3 lsl L00C3 rolB rolA bra LE554 ; LE548: ldX L00FC stX L00C4 callr LE53B addD L00C4 bra LE554 LE552: addD L00FC ; LE554: bcc LE565 ldD #$FFFF bra LE565 LE55B: stD L00C1 ldD L00FC subD L00C1 bcc LE565 clrA clrB LE565: stD L00FC ret ; ; ;correction for battery voltage ?? ;initial value passed in C3 ;value returned in D, limits are 0064 – FFFF LE568: ldX #$9346 call LE506 ; battery voltage correction staA L0102 ; store in A ldaB #$08 mul ; A * 8 addD L00C3 ; add L00C3 bcc LE57B ldD #$FFFF ; if carry set to max. LE57B: cpD #$0064 ; test for limit bcc LE582 ; OK return ldaB #$64 ; else set to lower limit LE582: ret ; ; LE583: lsrD ;shift right!! lsrD lsrD lsrD lsrD lsrD lsrD adcB #$00 adcA #$00 ret ; ; LE58F: lsrD lsrD lsrD LE592: lsrD lsrD ;rotate right 3 bits lsrD ;rotate right 2 bits lsrD ;rotate right 1 bit adcB #$00 ;add carry adcA #$00 ;add carry tstA ;set flags for A? beq LE59F ; B = B or ldaB #$FF ; B = FF LE59F: ret ; ;compare a value in A with the limits passed in Y stY L00C1 ;Y -> L00C1,C2 LE5A3: cmpA L00C1 bcc LE5A9 ldaA L00C1 LE5A9: cmpA L00C2 bcs LE5AF ldaA L00C2 LE5AF: ret ; ;compare a value in A with the limits passed in Y (default=0) stY L00C1 ;C1,C2 = two limits LE5B3: cmpA L00C1 ;A compared with C1 bcs LE5B9 ldaA L00C1 ;A compared with C2 LE5B9: subA L00C2 bcc LE5BE ;return clrA ;return default (00h) LE5BE: ret ; ; important maths or another compare?????? LE5BF: cmpA Y++ LE5C1: bcs LE5C8 deY LE5C5: ldaA X clrB subA X bcc LE5CE clrA clrB LE5CE: ldX Y cmpA Y bcc LE5CE stX L00C1 addA L00C1 LE5D8: dec L00C2 beq LE5E0 lsrD bra LE5D8 LE5E0: ret ; LE5E1: ldD L004D ; RPM/4 lslD lslD ; RPM bra LE5FB ; call E5BF ; LE5E7: ldD L005C ; MAP*51.5 LE5E9: xgdX ; or something else LE5EA: ldaB #$98 ; or $98 = 152 call LE45E ; ? * 152 subD #$199A ; $199A again!! (6554?) bcc LE5F6 clrA clrB LE5F6: bra LE5F9 ; LE5F8: lsrD lsrD lsrD callr LE5BF bra LE592 ; ;SUBR1_3: A/D Conversion - return result in AB LE5FF: staA ADCCR ;channel no. to control reg staA ADCRSLT ;two cycle delay?? brclr ADCCR, bit5, E603 ;poll busy flag ldaA ADCCR ; delay?? ldD ADCRSLT ;get result (overwrites AccA) ret ; ; isolates one bit and tests for a change?? LE60C: callr LE61A callr LE61A callr LE61A callr LE61A callr LE61A callr LE61A callr LE61A LE61A: bcc LE620 cmpA 0, X ;test for 0 bra LE622 LE620: cmpA 1, X ;test for 1 LE622: rorB xorB #%10000000 ;test change incX incX ret ; LE628: ldaA L00CD ldaB #$20 mul xgdX LE62E: ldaA L00CE ldaB #$20 mul tAB aBX stX L00CB ldD L00CD subD L009A bcc LE641 negA negB sbcA #$00 LE641: subD L00CB ret ; ; ; ; ISR1 – Input Capture 1 – CAS??? ; ISR1: ldX L0029 ; only when engine running ldaB T1CSR ;T1CSR ldD ICR1H ;IC1R ldD L002D ;TMR3 clock2??? stD L00CB ; mirror of 2D bset T1CSR,bit1,LE655 ; T1CSR LE652: jmp LE796 bset T3CSR0,bit7,LE65C ;T3CSR xgdX ;X = L002D, D = L0029 LE65A: stD L00CB subD L009E bset 0, X, #%01111101 ;set all bits except 7,2 bcc LE669 ldaA L008F cmpA #$0E bcc LE688 LE669: ldD L00CB subD L00A0 stD L00CD ldaB L0090 beq LE67A tstA bmi LE67F cmpB #$0E bhi LE67F LE67A: ldD #$FFFF stD L00CD LE67F: ldD L00CB addD #$000E LE684 brset 16 01 03 ;L0016 – Port5 bit0 LE688: jmp LE793 ; cpD L292A bitB LBDF3 adcA L8635 staA L0090 ldD L00CB stD L00A0 LE69A 8F B2 FF 04 ldaA L00CD bpl LE6BA clrA staA L0098 staA L0099 oim T3CSR0, #$C0 ; T3CSR0 set bits7-6 oim T3CSR1, #$A0 ; T3CSR1 set bits7,5 aim T3CSR1, #$F0 ; T3CSR1 clr bits3-0 brclr L00D7, bit5, LE6B7 ; check config LE6B4: call LF38B jmp LE762 ; ; LE6BA brclr 98 02 08 brset 16 02 19 ;Port5 brclr 99 03 15 oim T3CSR0,bit3-2 ;T3CSR0 LE6C9: ldX L0029 incX incX stX L002B stX L00AA clrA staA L0099 LE6D4 brclr D7 20 03 ;L00D7 call LF38B LE6DB brset 98 02 03 LE6DF: jmp LE762 ; LE6E0: staB 98, X ldaA L00B1 ;timing value? clrB ;B = 0 lsrD ;L00B1*8 lsrD lsrD lsrD stD L00CB ;store in L00CB ldaA L00CE ;get L00CE ldaB L015F ;dwell time?? mul ;dwell * L00CE staA L00A6 ;L00A6 = ldaA L00CD ldaB L015F mul LE6F9: addB L00A6 adcA #$00 lslD bcs LE704 cpd LCB25 LE703: aim L00DC, #$0CB stD L00A6 ldaB L00CE ldaA #$9C mul ;A*B->D staA L00CC ldaA L00CD ldaB #$9C ; mul addB L00CC adcA #$00 addD L00A4 subD L00A6 addD L00A0 stD L00CB ldD L00AA addD #$00FA cpD LCB2B aim L00DD, $CB brset PORT5, bit1, LE75A ;PORT5 bit1 brclr L0099, #$02, LE75E ldD L0029 ;timer??? addD #$000A xgDX LE739: cmpX L00CB ;CB = bpl LE73F ldX L00CB LE73F: stX L002B ldaA T3CSR1 stX L002B stX L00AC aim T3CSR0, #$FB ;clear T3CSR0, bit2 brset L00D7, #$20, LE755 ;bra if bit5 = 1 brset L0099, #$03, LE755 ;bra if bit0 1 bra LE7E0 LE755: clrA staA L0099 bra LE762 ; brset L0099, #$03, LE762 ldD L00CB stD L00AC LE762: ldaA T3CSR0 ;get counter andA #%00001100 ;isolate bits 2,3 oraA #%01000010 ;set bits 6,1 ldaB T1CSR ;get timer control andB #%00011001 ;clear bits ldX ICR1H staA T3CSR0 ;load counter staB T1CSR ;load timer control? ldaA #$18 ;18?????? brclr PORT3, #$40, LE779 ;br if L0006 bit6 = 0 LE778: lslA staA L012A ldaB L9825 staB L008D LE781 brclr 83 02 03 LE785 03 83 04 F6 98 D0 ldaB staB L0089 clr L0166 LE790 03 83 03 jmp LEB6B LE796 brclr 19 10 03 ;counter LE79A 1A LE79B: stD L00CB subD L00A0 bset 0, X, #%11111010 bcc LE7AA ldaA L0090 cmpA #$0E bcc LE7F7 LE7AA: ldD L00CB subD L009E stD L00CD ldaB L008F beq LE7BB tstA bmi LE7C0 cmpB #$0E bhi LE7C0 LE7BB: ldD #$FFFF stD L00CD LE7C0: ldaA L0098 andA #%00000101 lslA oraA #%00110101 ldX L00CD cmpX #$061A bcs LE7EC andA #%11011111 cmpX #$1081 bcs LE7D7 andA #%11111011 LE7D7: cmpX #$1306 bcs LE7DE andA #%11101111 LE7DE: ldaB #$49 bitA #%00000010 bne LE7E6 ldaB #$3A LE7E6: cmpB L00CD bhi LE7EC andA #%11111110 LE7EC: staA L00CF ldD L00CB addD #$000E LE7F3 brclr 16 01 03 ; Port 5 LE7F7: jmp LEB6B ; LE7FA: cpD L292A bitB LBDF3 adcA LDCCB stD L009E ldaA L00CF staA L0098 ldaA #$35 staA L008F ldD L00A2 subD #$0027 ldaA L00B0 addA L00D0 cmpA #$A0 bcs LE81C ldaA #$A0 LE81C: cBA bls LE82A addB #$3B bcs LE835 cBA bcs LE835 subB #$03 bra LE836 ; LE82A: subB #$11 bcs LE835 cBA bhi LE835 addB #$03 bra LE836 ; LE835: tAB LE836: ldX #$0027 aBX stX L00A2 addB L00B5 ;add some more timing? staB L00AF ;and save as new ignition timing value LE840 brclr 98 01 8F tAP negA neg 143, X tSX xgXY incB LE84C brset 98 02 0C LE850: call LE628 bcc LE8A8 ldX L00CD stX L009A jmp LE968 LE85C brset 98 20 3D LE860: ldaA L00CD cmpA #$18 bls LE86D call LE628 bcs LE86D bra LE8A8 ; LE86D: ldD L00CD cmpA #$1D bcc LE89D lsrD lsrD lsrD lsrD lsrD lsrD stD L00CB ldD L009A subD L00CD bcc LE88F ldD L00CD subD L009A subD L00CB bcs LE89D addD L00CD bcs LE8A8 bra LE89F ; LE88F: subD L00CB bcs LE89D stD L00CB ldD L00CD subD L00CB bcs LE8A8 bra LE89F ; LE89D: ldD L00CD LE89F: stD L009C ;9c bmi LE8A8 bset 1, X, #%01000110 bcc LE8AB LE8A8: jmp LE961 ; LE8AB: ldD L00CD stD L009A ldaB L00A3 ldaA L009D Vol Efficiency mul staA L00CB ldaA L00A3 ldaB L009C ;9c mul addB L00CB adcA #$00 LE8BF brclr A2 FF 02 addD L009C 9c lsrD stD L00A4 LE8C8 brclr 16 02 52 ;Port 5 LE8CC: ldaA #$02 staA L0099 LE8D0 brclr 98 04 06 ldD L00A6 LE8D6 brset 98 08 16 LE8DA: ldaA IgnDwel clrB lsrD lsrD lsrD lsrD stD L00CD ldD L009C ;9c subD #$1130 bcs LE8F2 lsrD lsrD lsrD lsrD addD L00CD stD L00CD LE8F2: ldD L00A4 subD L00CD addD L009E stD L00CD ldD L00AA addD #$00FA cpD LCD2B LE902 02 DD CD ldD L0029 addD #$000A xgdX LE909: clv LE90A 1A LE90B: cmpX L00CD bpl LE911 ldX L00CD LE911: stX L002B ldaA T3CSR1 stX L002B stX L00A8 LE919 02 19 FB jmp ; ldX L0029 decX stX L002B ldaA #$01 staA L0099 ldD L00A4 addD L009E stD L00AA ldaA L0099 cmpA #$02 beq LE94A ldD L0029 addD #$0006 xgDX LE939: cmpX L00AA bpl LE93F ldX L00AA LE93F: stX L002B ldaA T3CSR1 stX L002B LE945 03 19 0C clc stX L00AA ldD L009C ;L009C subD L00A6 addD L00A4 addD L009E stD L00AC ldD L00AA addD #$00FA cpD LAC2B stD L00AC bra LE98F LE961: ldX L00CD stX L009A clrA bra LE96A ; LE968: ldaA #$01 LE96A: staA L0098 ldX L0029 decX stX L002B ldaA T3CSR1 stX L002B LE975 02 19 FB aim T3CSR0 ldaA #$09 staA T3CSR1 ; timer csr?? clrA staA T3CSR1 ldD L009A stD L009C ;L009C clrA ldX #$00C7 stX L00A2 staA L0099 ldaA #$A0 ; base ignition timing? staA L00AF ; Ignition timing call LF3B9 ; call SCI routine at LF3B9 ldD L009A ; T2 input capture?? lslD bcc LE999 ldaA #$FF LE999: staA L00AE ldaA T3CSR0 ; Timer3 control ?? andA #%00001100 ; clear all but bits 3,2 oraA #%01010010 ; set bits 6,4,1 ldaB T1CSR ; Timer2 control andB #%00011001 ; oraB #%00000010 ldX ICR1H staA T3CSR0 staB T1CSR ldaA #$33 staA L00B2 ldX #$0224 ;L0224 = FIFO ?? ldD 4, X stD 6, X ldD 2, X stD 4, X ldD 0, X stD 2, X ldD L009A ;counter!!!!!! lsrD ;divide by 2 stD 0, X ;store in L0224 RPM???? ldaA L00D0 beq LE9CF subA L990B bcc LE9CF clrA LE9CF: ldaB L00D1 beq LE9D6 ldaA L990A LE9D6: staA L00D0 LE9D8 03 B3 80 brclr 1A 40 03 call LF363 ldaA L00B4 LE9E4 brset 07 01 0C L0007 ;test ignition switch LE9E8 brclr D7 02 04 brset 4B 80 04 LE9F0: tstA beq LE9F4 decA LE9F4 brset D7 20 04 brclr B3 01 05 02 B3 FC LEAAE: ldaA L00F2 beq LEAB5 decA staA L00F2 LEAB5: ldaA #$80 LEAB7 brclr 81 10 1A ;L0081 bit4 LEABB: ldaA L00F2 beq LEAD7 ldD L00E9 addD #$0080 tAB clrA addD L00EF stD L00EF dec >L00F1 bne LEADD LEACF 03 97 01 addD #$0080 staA L00E8 LEAD7: clrA clrB staA L00F1 stD L00EF LEADD: ldaA L00F6 subA L00F7 bcc LEAE4 clrA LEAE4: staA L00F9 ldaB L00F8 LEAE8 brset DA 08 23 LEAEC: ldaA L015B bne LEB0F LEAF1 brset 7E 20 0B brset 82 28 07 LEAF9: ldaA L0070 ;TPS Angle cmpA L9880 bcc LEB0F LEB00 brset 78 80 08 LEB04 brset D7 01 07 LEB08: ldaA L008B beq LEB0F ldaB L987F LEB0F brset 82 40 15 brset 81 04 11 ;L0081 bit2 LEB17 brset DA 08 0D brclr 95 10 09 ;L0095 LEB1F: ldaA L0130 beq LEB28 LEB24 brclr 95 01 18 ;L0095 LEB28 brclr D7 01 08 LEB2C brclr DA 08 04 ldaA L00DD bne LEB3B ldaA L00F6 mul staA L00F6 staA L00F7 LEB3B 02 97 F7 bra LEB47 ; LEB40: ldaA L00F6 beq LEB47 LEB44 03 97 08 LEB47: ldaA L00DD beq LEB4C decA LEB4C: staA L00DD ldaB L989A LEB51 brclr 78 80 0E lsl L800E LEB40: ldaA L00F6 beq LEB47 LEB44 03 97 08 LEB47: ldaA L00DD beq LEB4C decA LEB4C: staA L00DD ldaB L989A LEB51 brclr 78 80 0E LEB55 brset 78 10 06 brclr 7A 02 09 LEB5D: bra LEB63 ; LEB5F brclr 7A 40 03 LEB63: ldaB L9899 ldaA L00FA mul staA L00FA call LF3B9 reti ; ; ;Call EB94 if: ; L00D7 bit5 = 0, bit0 = 0 ; L00B3 bit0 = 0 ; L0007 bit0 = 0 = Ignition ON ; L00D7 bit1 = 1 AND L0043 = 0 ; L00D7 bit1 = 0 OR L0081 bit1 or 0 = 0 ISR2: ldaA T2CSR ;T2 control?? ldX T2ICR ;Input capture?? brset L00D7, bit5, LEB93 ;nothing to do brset L00B3, bit0, LEB93 ;nothing to do oim L00B3, bit0 brset PORT4, bit0, LEB93 ;bra if ign off brclr L00D7, bit1, LEB8A brset L0043, bit5, LEB93 ;nothing to do brset L0081, bits0,1, LEB93 ;bra if bit1 or 0 are set LEB8E: ldD L00FE ;D = Inj PW call LEB94 ;do another timer reti ; ; ;test Counter L0009,A (1MHz?) against OCR1H,C ;L0002 is PORT1, bit 3 =??, toggled?? Injector???? ;T2CSR is T2 control ; ;called from: F06F ;EB90 (ISR2) - calls (can’t log?), D = FE ;F39D (ISR5) - calls (logs continuously) LEB94: stD L00CB ;L00CB ldD OCR1H ;B = L000B (counter??) subD TMR1H ;B = B-9 (counter??) brclr PORT1, bit3, #$LEBA8 ;input low nop subD #$000A ;D = D-A bcs LEBA8 subD L00CB ;D = D-CB bcc LEBBB oim T2CSR, bit5 ;flag Port1.3 = 1 LEBAB: ldD TMR1H ;D = timer addD #$0003 ;add 3 to D stD OCR1H ;store $1817 at L000B,C brn $EBB2 aim T2CSR,bit5 ;flag port1.3 = 0 addD #$CB ;add CB to D stD #$0B ;B = next ‘tick’ ret ; ;RTI Interrupt routine ; ISR3: ldaA L0026 ;clear flag? ldaA L0027 inc >L0084 LEBC3 brclr 30 18 04 ;L0030 = PORT7 DDR? brset 06 40 1A ;L0006 = PORT3 LEBCB brset 16 01 16 ;L0016 = PORT5 LEBCF: clrA staA L0098 staA L0099 ldaA #$33 staA L00B2 LEBD8 brset 08 80 09 02 19 FB LEBDF: ldX L0029 incX incX stX L002B ldaA L0114 incA cmpA L98C9 bcs LEBEF clrA LEBEF: staA L0114 cmpA IACMon ;IAC Adjust Monitor bcc LEBFB aim PORT7, #$BF ;clear PORT7 bit6 jmp LEBFE oim PORT7, #$40 ;set PORT7 bit6 ;Comms LEBFE brset D2 80 23 ;L00D2 bit7 ldY #$114F ldaB L022C ;L022C is offset this time beq LEC10 decA cmpB #$09 bcs LEC14 LEC10: staA SCITX ;SCI_TX???? bra LEC20 ;send data using B as offset? LEC14: ldX #$022C aBX ;X + B ldaA 0, X ;Load A from X + B staA SCITX ;SCI_TX?? xgDY ;D=Y, Y=D LEC1E: staB 0, X inc L022C ;inc offset L022C bra LEC36 ; LEC25 brclr D2 40 0D ;L00D2 bit6 LEC29: ldD TMR1H ;timer? subD L0236 ;comms timeout? cpD #$0780 bcs LEC36 call LF3D4 LEC36 brclr 84 01 01 ;L0084 bit0 reti ; LEC3B 02 26 BF ei ldaA L0087 beq LEC49 ldaA PORT6 ;PORT6 xorA #%00100000 staA PORT6 ;toggle watchdog timer LEC49: ldaA L0091 beq LEC52 decA staA L0091 bra LEC55 ; LEC52 02 DA FD LEC55: ldaB L0085 rol >L0085 ldaA PORT1 ;PORT1 rolA ror >L0085 xorB L0085 bpl LEC76 ldaB L0091 beq LEC71 ldaB L986A staB L0143 LEC6E 03 DA 02 LEC71: ldaB L9869 staB L0091 LEC76 brclr 84 03 03 jmp LF09A ldx #$0086 LEC80: ldaB #$0B ;OR1 ;Loop Bx LEC82: ldaA 0, X beq LEC88 dec 0, X LEC88: incX decB bne LEC82 LEC8C brclr D7 20 03 call LF1E8 ldaA L0086 bne LEC9D LEC97 03 86 05 LEC9A 03 85 01 LEC9D: ldaA L0092 beq LECA4 decA bne LECB3 LECA4: ldaA #$FF brclr L0024,bit7,LECAC ; ldaA #$25 ;A= $25 LECAC: staA L0093 ;VSS = $FF or $25 clrA staA L0025 ldaA #$8D staA L0092 LECB5 brclr 84 07 03 jmp LEE6F ; LECBC: ldaA #$07 ;call A/D for TPS di call LE5FF ei staA L005B ;TPS Volts cmpA #$F8 ;TPS - Upper limit bhi LECD2 cmpA #$08 ;TPS – Lower limit bcs LECD2 ;bra if LECCD 02 82 F7 aim L0082, bit3 ;clr L0082, TPS bra LECDB ; oim L0082, bit3 ;set L0082 TPS ldaA L989B staA L0128 LECDB: ldD L0041 comB cBA beq LECEB LECE1 02 43 FB ldaA ;load A with L00D7 taB ;D = AA comB ;complement what was L00D7 stD L0041 ; L0041 = invA, A LECEB brclr 79 80 43 LECEF: brset 81 03 3F ; L0081 bit1-0 ; ;do the following TPS calculations only if the throttle opener is not activated ; LECF3: brset 2F 08 3B (LF0B2) ; test PORT6 bit3, throttle opener? LECF7: ldaA L005B ; Get TPS Volts cmpA L98D6 ; TPS Volts - $1D bcs LED32 cmpA L98D7 ; TPS Volts - $39 bhi LED32 brset L0087, bit2, LED0F LED07: cmpA L0041 ; TPS Volts – L0041 bcc LED0F tAB ; A,B = TPS Volts comB ; invert TPS Volts stD L0041 ; L0041 = !TPS Volts ;calculate delta TPS LED0F: subA L0168 ; calculate delta TPS bcs LED32 ; deceleration cmpA #$01 ; A - $01 bhi LED32 ; acceleration ldaA L0126 ; no change bne LED3D ldaA L0168 ;last TPS cmpA L0041 ;last TPS-L0041 bls LED2B brset L0046, bit5, LED3D LED28: ldaA L0041 ; get L0041 incA tAB comB stD L0041 lsrD ldaA L005B ; get TPS Volts staA L0168 ; store in L0168 ldaA L98D8 staA L0126 LED3D brset 43 04 0C LED41: ldaA L0128 beq LED4D ldaA L98D7 ; compare A with #$39 tAB comB stD L0041 LED4D: ldD L0071 stD L0072 ldaB L0070 ;TPS Angle ldaA L005B ; get TPS Volts subA L0041 ; TPS Volts - TPS Idle LED57: bcc LED5A clrA LED5A: stD L0070 ; TPS Angle ldaA L0070 ; TPS Angle subA L0072 bcc LED63 negA LED63 brclr 83 08 05 cmpA L9821 bra LED6F ; LED57: bcc LED5A clrA LED5A: stD L0070 ;TPS Angle ldaA L0070 ;TPS Angle subA L0072 bcc LED63 negA LED63 brclr 83 08 05 cmpA L9821 bra LED6F ; LED6C: cmpA L9822 LED6F: bcs LED7B ldaA L9823 staA L008A LED76 03 83 08 bra LED7B LED7B 02 83 F7 LED7E: ldaB L0070 ;TPS Angle cmpB L9897 bcc LEDA8 cmpB L0071 bhi LEDA8 ldaA L0073 sBA bcs LEDA8 cmpA L9895 bcs LEDA8 ldaA L0071 subA L0070 ; TPS Angle ldaB L9896 mul tstA bne LEDA3 di addB L00FA bcc LEDA5 LEDA3: ldaB #$FF LEDA5: staB L00FA ei EDA8 brset 81 03 20 ;L0081 bit1-0 brset 82 28 1C LEDB0: ldaA L0128 bne LEDCC LEDB5 brset D7 01 08 LEDB9: ldaA L0154 addA L9829 bcs LEDCC ldaA L0070 ;TPS Angle subA L0073 bcs LEDCF cmpA L9898 bcs LEDCF LEDCC: clr >L00FA LEDCF: ldaA L00D1 beq LEDD4 decA LEDD4: ldaB L0070 ;TPS Angle cmpB L990D bcc LEDE1 LEDDB 02 DA DF clrA bra LEE31 ; LEDE1: cmpB L990E bcs LEE31 LEDE6 brset DA 20 44 LEDEA: subB L0071 bcs LEE2E cmpB L990F bcs LEE2E LEDF3 brclr D7 38 37 LEDF7 brset 78 10 33 LEDFB brset D7 01 18 LEDFF brset D7 20 0A brclr DC 10 27 brset DC 20 23 LEE0B: bra LEE1F ; LEE0D brclr E4 10 1D brset E4 20 19 bra LEE1F LEE17 brclr DC 04 13 brset DC 08 0F LEE1F brclr 7E 80 0B LEE23 brclr 80 04 07 brset 80 08 03 LEE2B: ldaA L990C LEE2E 03 DA 20 staA L00D1 beq LEE3A ldaA L990A staA L00D0 LEE3A: ldaB L0070 ;TPS Angle cmpB L0071 bhi LEE61 ldaA L0073 sBA bcc LEE46 clrA LEE46: cmpA L9895 bcs LEE61 ldaB L993B staB L013C LEE51 brclr B8 04 09 ldaA L018E beq LEE5E decA staA L018E LEE5E 02 B8 FB B6 01 3C ldaA bne LEE6C ldaA L993C staA L018E LEE6C: jmp LF011 ; LEE6F: ldaA #$06 ;call A/D for O2 sensor? di call LE5FF ei lslB ;multiply D*2? rolA ;multiply A*2 add carry bcc LEE7C ;AB > 80? ldaA #$FF ;A = FF LEE7C: staA L005A ;O2 sensor = $FF brclr L00D7, bit5, LEE90 ;config bit ldX #$95BB ldaB L0096 beq LEEE0 cmpB #$0A beq LEEE0 incX bra LEEE0 ; LEE90 brclr D7 10 05 LEE94: ldD #$957F bra LEEAB ; LEE99: clrA clrB brclr, L00D7,bit0, LEEA1 addB #$14 LEEA1 brclr D7 08 03 addD #$003C addD #$9557 xgDX ;load X offset LEEAC: clrB LEEAD brclr 78 80 04 LEEB1 brset 97 40 08 LEEB5: ldaB L0096 cmpB #$0A bcs LEEBD subB #$0A LEEBD: lslB ldaA L0074 cmpA L983C ; =#$2E? bcs LEECA LEEC5 03 DE 01 bra LEEDA ; LEECA brclr D7 10 09 cmpB #$12 bne LEED7 cmpA L983E bcc LEEDA LEED7 02 DE FE aim LEEDA brset DE 01 01 LEEDE: incB aBX ldaA L005A ; O2 sensor ldaB 0, X bne LEEEB lslD bcc LEF10 bra LEF0D ; LEEEB: mul stD L00C8 ldaA L0076 ldaB 0, X mul staA L00CA ldaA L0075 ldaB 0, X mul addB L00CA adcA #$00 lsrD adcB #$00 adcA #$00 negA negB sbcA #$00 addD L0075 addD L00C8 bcc LEF10 LEF0D: ldD #$FFFF LEF10: stD L0075 lsrD addD #$0080 ldaB L0074 cmpB L983C =#$2E? bcc LEF27 cmpA L983C =#$2E? bcs LEF3B ldaA L983C =#$2E? bra LEF30 ; LEF27: cmpA L983C bcc LEF3B ldaA L983C =#$2E? decA LEF30: tAB lslB bcc LEF36 ldaB #$FF LEF36: staB L0075 clr >L0076 LEF3B: staA L0074 ldX #$98CC brclr L0082,#$29,LEF56 ; L0082, TPS,MAP brset L0081, bits 1,0, LEF4C ldaB 0, X ;98CC = $CD LEF4A: staB Baro_x ;Baro Pressure LEF4C 03 83 04 ldaA 1, X staA L0088 jmp LF001 ; brset L0081, #$03,LEF61 ;L0081 bits0 or 1 =1?? ldaB L0070 ;TPS Angle cmpB L0119 bcc LEF67 ldaA 1, X staA L0088 bra LEF74 ; LEF67: ldaA L0088 bne LEF74 ldD L0064 ; Get MAP * 256 lsrD ; div by 4 lsrD addB L011A ; add something staB Baro_x ; Baro Pressure brset L0083, bit1, LEFC0 LEF78: ldaA L0058 ; get Batt_Raw cmpA 3, X ; Batt_raw – 8.03V bcs LEF90 ldaB L0059 ; get MAP_Raw cmpB L0165 bcc LEF88 staB L0165 LEF88: cmpB L0166 ;L0166 bls LEF90 staB L0166 LEF90 brset 83 04 6D brclr 06 40 06 LEF98: ldaA L0058 ; get Batt_Raw cmpA 3, X ; Batt_Raw – 8.03V bcc LEFA4 ldaA 4, X ; Batt_Raw – 1.47V ?? staA L0089 bra LF001 ; LEFA4: ldaA L0089 bne LF001 ldaA L0166 subA L0165 cmpA 6, X bhi LF001 ldaB L0059 ; get MAP_Raw subB 5, X ; MAP_raw - ? bcc LEFB9 clrB ; clear Baro Pressure LEFB9: staB Baro_x ; store Baro Pressure LEFBB 03 83 04 20 41 LEFC0: ldaA L0050 ; RPM manipulated cmpA 2, X bcs LEFD6 ldaA L0058 ; Get Batt_Raw cmpA 3, X ; Batt_Raw – 8.03V? bcs LEFD6 ldD L0064 ; get MAP * 256 lsrD lsrD ; MAP * 64 cmpB Baro_x ; Baro Pressure bls LEFD6 staB Baro_x ; Baro Pressure LEFD6 brset 83 04 27 LEFDA: ldaA L0058 ; Get Batt_Raw cmpA 3, X ; Batt_raw – 8.03V bcs LEFEA ldaB L0059 ; Get MAP_Raw cmpB L0166 bls LEFEA staB L0166 LEFEA: ldaA L0089 bne LF001 ldaB L0166 beq LF001 tBA subB L0165 cmpB 7, X bhi LEFFE tAB staB Baro_x ;Baro Pressure LEFFE 03 83 04 ldaB Baro_x ;Baro Pressure cmpB 8, X bcc LF009 ldaB 8, X LF009: cmpB 9, X bls LF00F ldaB 9, X LF00F: staB Baro_x ;Baro Pressure ldaA L008E bne LF029 brset L0081,bit1,LF029 ldaA L9824 staA L008E ldaA L008D beq LF029 ldD L00FE ;Inj PW di call LEB94 ;timer ei brset L0081,bit1-0,LF091 ldaA L0070 ;TPS Angle ldaB L00FB cBA bls LF075 tBA addB L9890 bcc LF03C ldaB #$FF LF03C: staB L00FB brset L0097,bit7,LF047 LF042: cmpA L988F ;L988F = bcc LF097 brset PORT4,bit0,LF097 ;bra if ignition off brclr L00D7,bit1,LF053 ; L00D7 = ECU config LF04F brset 43 20 44 ; L0043 = I2C control? LF053: brset 81 03 40 ; L0081 bit1-0 ?,closed loop? brset 46 04 3C ; L0046 – IFS fault brset 82 28 38 ; brset L0082, bit5|3 ;L0082, TPS? LF05F: ldaA L0128 bne LF097 brclr PORT3,bit7,LF097 ; PORT3 Idle Switch? LF068: 03 B8 04 ldX L0100 di call LEB94 ;timer ei bra LF097 ; LF075: addA L9891 bcs LF093 subB L9890 cBA bhi LF097 ldaB L9890 staB L00C8 tAB clrA bclr L00C8, #%01001101 beq LF08D incB LF08D: ldaA L00C8 mul tstA beq LF095 LF093: ldaB #$FF LF095: staB L00FB LF097: jmp LF1E3 ; LF09A: ldaA #$05 di call LE5FF ei staA L0059 ; MAP?? cmpA #$E8 ;Upper limit? bhi LF0BD cmpA #$0B ;Lower limit?? bcc LF0C2 ;bra if >= to $0B ldaA L0050 ;;RPM manipulated cmpA L98BC ;compare with $30 bcs LF0BD ;bra if L0050 < $30 LF0B2 brset 82 28 0F LF0B6: ldaA L0070 ;TPS Angle cmpA L98BD ;lower limit = 0Ch bcs LF0C5 oim L0082, bit0 ;clr L0082 MAP bra LF0C5 ; aim L0082, bit1 ;set L0082 MAP ; LF0C5: ldD L0062 ldX #$F129 callr LF12B xgDY LF0CE: ldD L0060 ldX #$F127 callr LF12B lslD rol >L00CA LF0D9 CD DF C8 LF0DC: subD L00C8 bcc LF0E8 LF0E0 brset CA 01 08 LF0E4: clrA clrB bra LF0EC brset L00CA bit0 LF0F7 LF0EC: stD L00C8 clrA ldaB L0059 ; MAP_Raw lslD ; MAP_Raw*4 lslD addD L00C8 ; (MAP_Raw*4)+L00C8 bcc LF0FA ldD #$FFFF LF0FA: stD L005E addD L0062 rorA rorB adcB #$00 adcA #$00 addD L0060 rorA rorB adcB #$00 adcA #$00 ldX #$F125 callr LF12B lsrD lsrD lsrD lsrD adcB #$00 adcA #$00 stD L0064 ; L0064 ldD L0060 ; buffer the MAP stD L0062 ldD L005E stD L0060 bra LF15D ; LF125: decB ; previous bras to F12B!!!!! sbcB L00E3 oraA 205, X LF12A 02 36 37 aim ldaA 1, X mul staA L00C9 popB ldaA 0, X mul addB L00C9 ;main relay ON here??? adcA #$00 stD L00C8 popA pushA ldaB 1, X mul addD L00C8 stD L00C8 popA rorB andB #%10000000 pushB ldaB 0, X mul xgDX LF14E: popB aBX aBX ldaB L00C8 aBX xgDX LF155: lsl >L00C9 adcB #$00 adcA #$00 ret ;end sub ; ; ; ; ; LF15D: ldD L0064 ;L0064 lsrD lsrD tstA beq LF166 ldaB #$FF LF166: tBA ldaB L006A ldX L0068 stX L0069 ldX L0066 ;L0066 – get previous MAP stX L0067 ;back up at 67 staA L0066 ;L0066 = Manifold pressure kPa cmpA L0067 bcs LF1AD sBA bcs LF1CA ldaB L015B bne LF187 LF17F brset 78 10 04 brset 80 20 05 LF187: cmpA L987B bra LF198 ; LF18C brset D7 01 05 LF190: cmpA L987C bra LF198 ; cmpA L987D LF198: bcs LF1CA ldaA L0066 ;L0066 = MAP subA L0067 ;MAP - ? lslA ; * 2 bcs LF1A6 di addA L00F6 bcc LF1A8 LF1A6: ldaA #$FF LF1A8: staA L00F6 ei bra LF1CA ; LF1AD: sBA bcc LF1CA negA cmpA L987E bcs LF1CA ldaA L0067 subA L0066 ;L0066 = MAP lslA bcs LF1C6 staA L00C8 di ;disable interrupts ldaA L00F6 ;Load A with F6 subA L00C8 ;A = A- contents of C8 bcc LF1C7 ;test carry LF1C6: clrA ;clear A if carry LF1C7: staA L00F6 ;store in F6 ei ;enable interrupts LF1CA brset 81 03 04 ;L0081 bit1-0 brclr 82 01 03 ;L0082 MAP LF1D2: clr >L00F6 ;clear contents of F6? ldaA L0059 ; MAP(kPa) LF1D7 brset 81 03 05 ;L0081 bit1-0 LF1DB: cmpA L0167 ;compare A with bcc LF1E3 staA L0167 ;store at 0167 LF1E3: di ;disable interrupts LF1E4 03 26 40 oim ;set bit 6 in location 40 CEL reti ; ; ; LF1E8: ldX #$0100 inc L016C LF1EE brset 78 80 03 LF1F2 02 77 FB brclr E5 80 11 brset 77 20 09 03 77 20 LF200: ldaB L9931 call LF314 ldaA 42, X bne LF217 LF20A brset 77 40 09 03 77 40 LF211: ldaB L9930 call LF314 LF217 brclr 7A 01 16 LF21B brset 78 40 12 brset 77 10 11 03 77 10 LF226: ldaB L9932 call LF314 LF22C 02 77 BF 20 03 LF231 02 77 stX tst L400F LF238 brset 77 08 0E 03 77 08 LF23F: ldaB L9933 call LF314 bra LF24A ; LF247 02 77 F7 LF24A: ldaB L016A cmpB L0169 bne LF273 LF252 02 77 7F tstB bne LF273 LF258 brclr 78 80 17 lsl L8017 ldaA L0091 beq LF264 LF260 brclr E4 02 0F LF264 brset 77 04 0B 03 77 04 LF26B: ldaB L9934 addB #$04 call LF314 LF273 brset 46 40 29 LF277 brset 07 0C 0A ;PORT4 02 77 FD LF27E: ldaA #$78 staA L013F bra LF288 ; ; LF285 03 77 02 LF288: tst L013F bne LF2A0 LF28D 02 77 FD brset 46 40 0C ;Fault Codes LF294 03 46 40 F297 03 47 40 negA ldaB L9935 call LF314 F2A0 brclr B8 01 16 F2A4 brclr E4 01 12 brset B8 02 11 F2AC 03 B8 02 ldaB call LF314 F2B5 02 B8 FE 20 03 F2BA 02 B8 FD brset 77 02 52 ldaA L016B ldaB L016A cmpB L0169 beq LF313 bcc LF2DD F2CE C7 6C 01 41 FCD2 brclr 77 01 02 LF2D6: incA incB F2D8 03 77 01 bra LF2E5 F2DD brclr 77 01 09 F2E1 C7 6C 01 2E F2E5 02 77 FE bra LF313 cmpB L9936 bhi LF2F3 F2EF C7 6C 03 20 decA LF2F4: decB andA #%00000011 staA L016B staB L016A F2FD brset E4 01 03 F201 03 B8 01 LF304: di ldX #$95ED ;X=95ED tAB ;D=AA ldaA PORT7 ;test PORT 31 andA #%11111100 ;isolate bits 7-2 aBX ;X+B addA 0, X ;A=X+A staA PORT7 ;store PORT 31 ei LF313: ret ; ; LF314: addB L016B cmpB L016A bcs LF31F staB L016A F31F 03 77 80 7F 01 69 F325 39 ; ; ISR4 – Timer 2 Output Compare ; ISR4: ldaA T2CSR ;T2CSR ldX T2OCR ;OC2 register stX T2OCR xorA #%00000001 ;toggle output? staA T2CSR ;T2CSR ldD L00BE F332 brset 18 01 10 ;T2CSR – Input Capture IE LF336: ldX #$0140 dec 73, X F33B C7 49 04 03 ;address 49 and X ??? LF33F: subD #$00FA addD L00BC bra LF34B ; LF346: addD #$1388 stD L00BE pushB pushA popX subD #$1388 subD TMR1H ;Timer1 subD #$EC80 bcc LF35D ldaB #$04 ldX TMR1H ;Timer1 aBX ;add 4 to timer LF35D: stX T2OCR ;store in T2OCR reti ; ' ;ISR5 - Another counter??? ; ISR5: callr LF363 reti ; LF363: ldX L0029 ;get Timer3 decX ;decrement stX L002B ;store in output compare reg ldaA T3CSR1 ;clear IF? stX L002B ; brset L0099, bit1, LF3A1 ;injector status??? brclr L0099, bit0, LF3B5 ;bit0 = nothing to do LF374: ldD L0029 ;get Timer3 addD #$0009 ;add x secs cpD LAC2A ;compare with LAC2A aim L00DC, #$AC ;clr L00DC bits6,4,0,1 stD L002B ; store in output compare reg aim T3CSR0, #$FB ;clr bit2 T3CSR – enable OC2??? clrA stA L0099 brclr L00D7, bit5, LF3A0 ;return - nothing else to do brset PORT4, bit0, LF3A0 ;return - nothing else to do brclr L00D7, bit1, LF397 ;t brset L0043, bit5, LF3A0 ;return - nothing else to do brset L0081, bit1,0 LF3A0 ;return - nothing else to do LF39B: ldD ;D=Inj PW call LEB94 ;timer?? ret ;return to rti ; ; LF3A1: ldD L0029 addD #$0008 cpD LAA2A F3A9 02 DC AA stD L002B F3AE 03 19 0C ldaA #$01 staA L0099 ret ; ; ISR6 - SCI Interrupt ; ISR6: bsr LF3B9 rti ; ;check for RX or TX LF3B9: ldD SCICR ; A = L0011 and L0012 ldX TMR1H ; X = L0009/A (counter!!) bitA #%00010000 ;check for RX pending beq LF3CB bitA #%01000000 ;check for RX errors bne LF3D4 bitA #%10000000 ; data to be sent? beq LF3E0 ;No Return bra LF3E1 ;Yes? ; LF3CB: andA #%00100100 ;A = L0011 cmpA #$24 ; TX en OR ERR???? bne LF3E0 ;if TX not enabled return jmp LF52F ;else send data ; LF3D4: clrA staA L00D3 ;clear L00D3 staA L00D4 ;Clear L00D4 aim L00D2, #$BF ;clear L00D2 bit6 (data received) ldaA #$19 ;enable RX and RXIE staA SCICR ;load to SCI control reg LF3E0: ret ; ; ;ISR6_1 RX -Build message ; LF3E1: stX L0236 ;back up X reg (tick) tBA ;RX data to A?? addA L00D4 ;add A to L00D4 (checksum?) staA L00D4 ;STORE ldaA L00D3 ;A = L00D3 (byte counter?) beq LF40E ;Byte counter=0 decA ;1 byte less beq LF411 decA cmpA L022D ;A - Msg Length bcs LF414 ;if not end of message store data beq LF3FD ;end of message aim L004B, bit7 ;clear L004B bit7 LF3FB: bra LF3D4 ;abort? LF3FD: ldaA L00D4 ;csum? bne LF3D4 ;cclear down if csum error? ; ;end of message bra to LF417 or bra from jump table ldaA L00D3 ;Get Byte Count cmpA #$07 ;Byte Count - 7 beq LF417 ;end of message? cmpA #$04 ;Byte count - 4 beq LF417 ;end of msg? jmp LF4C3 ; LF40E: jmp LF4D2 ;byte counter=0 jmp LF4F6 jmp LF522 ;store data ; ; end of message?? LF417: ldX #$977D ;977D = $00 clrB ; B = 0 ldaA L0049 ; 49 = ?? andA 0, X ;AND with $00 cmpA 14, X ;L9791 = $05? bne LF4A0 ldaA L004A ;L004A = ?? andA 1, X ; L004A & $00 cmpA 15, X ; A - $00 bne LF4A0 cmpB #$03 ;cmpB with 03?? (B=0?) bne LF448 ldaA L022C cmpA L97A7 ;cmp L022C with $19 bne LF444 ldaA L022E ;encryption key?? cmpA L97A8 ;cmp L022E with $82 bne LF444 lsrD ;r shift D (A7 = 0) bra LF456 ;send $19 ; not $80 or 82? brset L004C, bit2, LF4A0 LF448: ldaA L022C cmpA 28, X ;cmp L022C with $19 bne LF4A0 ldaA L022E cmpA 29, X ;cmp L022E with $80 bne LF4A0 ; $19,$80 or $19, $82 brset L0048, bit1, LF4AE ;TX?? LF45A: tstB ;?? B = carry+0?? bne LF47C brset L0048, bit3,LF4AE brclr L0049, bit7, LF469 brset L004A, bit3 OR 0, LF4AE LF469: ldaA L0141 ;A = L0141 addA L993A ;A + $96 bcc LF4AE clr >L0049 ;L0049 = 0 aim L004A, bit7 ;clear L004A, bit7 clr >L004C ;clear L004C bra LF4B1 ; LF47C: cmpB #$06 ;B = 6? bne LF490 brset L0043, bit6, LF4AE ldaA #$10 cpA L0139 ;L0139 = $10?? LF489: bcs LF4B6 ;bra if A <10 staA L0139 ;else L0139 =10 bra LF4B6 ; brset L004C, bit0, LF4A0 LF494: cmpB #$02 bne LF4B1 ;bra if B!=02 ldaA L022F ;A = L022F (csum/byte1) cmpA L97A9 ;cmp L022F with $81 beq LF4B1 ;if equal bra LF4A0: cmpB #$06 bcc LF4AA ;bra if B => 06 incB ;B = B+1 incX incX ;X = L977F jmp LF41B ; brset, L0049, bit7, LF4C3 LF4AE: jmp LF3D4 ;RX message complete? ; LF4B1: ldaA #$10 staA L013A ;L013A = $10 ldaA #$01 ;A = 1 tstB beq LF4BF ;if B=0 then LF4BF LF4BB: lslA ; A = 2 decB ;B - 1 bne LF4BB LF4BF: oraA L004B staA L004B ;set bit2 L004B clrA staA L00D3 ;clear L00D3 staA L00D4 ;clear L00D4 ldaA #$78 staA L0127 ;L0127 = $78 ldaA #$0E ;Rx En, TX en, TXIE en staA SCICR ret ; ; ;$10, 13, 14, 15, 18, 19, 1E = LF4ED (start of message?) ;others = F4AE – clear registers (invalid headers?) ; ; ISR6_2 TX Routine?? ;byte counter = 0? LF4D2: staB L022C ;Header byte cmpB #$10 beq LF4ED ;bra if =$10 cmpB #$13 bcs LF4AE ;bra if <$13 cmpB #$15 bls LF4ED ;bra if =<$15 cmpB #$18 bcs LF4AE ;bra if <$18 cmpB #$19 bls LF4ED ;bra if =<$19 cmpB #$1E bne LF4AE ;bra if !=$1E oim L00D2, #$40 ldaA #$18 ;RXIE en RE enabled staA SCICR ;load SCI control reg bra LF51E ;inc byte count and rtn ; LF4F6: subB #$03 ;B - 3 staB L022D ;Message Length?? tBA ldX #$976F ;X = 976F ldaB L022C ;B = L022C subB #$10 beq LF514 ;L022C = Hdr 10? subB #$02 cmpB #$03 bls LF514 ;bra if B < $03 subB #$02 cmpB #$05 ;bra if B < $05 bls LF514 ldaB #$06 ;B = $06 LF514: lslB ;B = $08 or ? aBX ;B -> X cmpA 0, X ;L976F = $00 bcs LF4AE ;bra if X < A cmpA 1, X ;L9770 = $00 bhi LF4AE ;bra if msg complete inc >L00D3 ;inc L00D3 (byte counter?) ret ; ;store RX data in buffer LF522: tBA ;D = copy RX data to A? ldX #$022C ;X = 022C, base address of buffer ldaB L00D3 ;B = L00D3, byte counter aBX ;X = add byte count staA 0, X ;store RX data incB ;inc byte counter staB L00D3 ;update byte counter ret ; ;send data??? LF52F: stX L0236 ldaA L00D3 ;A = counter?? beq LF567 ;0 = header byte? decA ;A-1 beq LF550 ; if 0 now (send csum??) decA ;A-1 (again?) cmpA L022D ;A - Msg Length bcs LF557 ;bra if A < L022D beq LF561 clrA staA L00D3 ;clear L00D3 staA L00D4 ;clear l00D4 ldD SCICR ;get SCI control and RX reg ldaA #$1B staA SCICR ;TX en, RX en RXIE en F54C aim L00D2,#$BF ;clear L00D2, bit 6 ret ; LF550: ldaA L022D ;L022D add 3 addA #$03 bra LF564 ;send data ; LF557: ldD #$022C ;L022C, 022D addB L00D3 ;add L00D3 xgDX ;X = D LF55D: ldaA 0, X ;A = (X) bra LF564 ;send data ; ;send first byte? LF561: clrA ;A = 00 subA L00D4 ;clear checksum jmp SENDTX ;send data ; ;filter message by header LF567: ldaA L022C ;A = Header Byte subA #$10 ;Header = $10 beq LF5B2 subA #$03 ;Header = $13 beq LF5BF decA ;Header = $14 beq LF5A6 decA ;Header = $15 beq LF5A9 subA #$03 ;Header = $18 beq LF5AC decA ;Header = $19 beq LF5AF ;if not one of above = $1E ldaA #$08 staA L022D ;msg length = 8 ldX #$022E ;point to first byte LF587: ldaB 0, X ;B = >L022E clrA ;A = 00 xgDY ;Y = AB LF58C: ldaB 128, X ;B = >L02A4 staB 0, X ;L022E = L02A4 incX ;X = 022F cmpX #$0232 ;cmp 022F with $0232 bcs LF587 ;repeat if X < $232 LF596: ldX 0, Y ;X = Y ldD 128, X ;D = (X+128) stD 0, X ;(X) = D incX incX ;X+2 cmpX #$0236 bcs LF596 ;repeat X < $236 bra LF5F8 ;send contents of L022C ; ; jump table for other message types LF5A6: jmp LF605 ; $14 jmp LF60F ; $15 jmp LF620 ; $18 jmp LF6AE ; $19 ; ; $10 LF5B2: ldaA #$02 staA L022D ; L022D = $02 ldD #$1112 ; D = 1112 stD L022E ; AB = L022E,022F bra LF5F8 ; send contents of L022C ; $13 ; Diagnostics TX, Msg Length? LF5BF: ldX #$022D ldaB L022D ; byte offset?? beq LF5F8 ; send contents of L022C aBX ; X=X+B ; Diagnostics – Data address offset ldaB 0, X ;B = (X) brclr, L004B, bit6, LF5D0 LF5CE: subB #$60 ;B=B-60 bra LF5D8 LF5D2: cmpB #$1F ;above top of table? bls LF5D8 ldaB #$1F ;if above default to top of table LF5D8: lslB ; B*2 data = 16 bits ldY #$9719 ; start of diagnostics addresses? aBX ; X = X+B ldX 0, X ; point to address ldaB 0, X ; data into B staB 0, Y ; B -> Y decX ; X is a counter ?? cmpX #$022E ; last byte ?? bcc LF5C8 ; loop?? ; ; Send Header Byte brclr L004B, bit2, LF5F8 ;send first byte aim L004B, #$FB ;clr L004B, bit2 oim L0049, bit2 oim L004A, bit2 LF5F8: ldaA L022C ; ;Send TX data SENDTX: staA SCITX ;Load A to TX reg addA L00D4 ;add A to Csum staA L00D4 ;store csum inc >L00D3 ;inc byte counter ret ; ; $14 LF605: incA staA L022D ;Msg Length incA staA L022E ; Tx Data Byte bra LF5F8 ; send data ; $15 LF60F: staA L022D ; L022D = A ldD L022E ; Data Bytes 1 and 2 stD L0163 ; Actuator Byte 1,2 = L022E,F ldD L0231 ; Data Bytes 4 and 5 stD L016D ; Actuator Byte 1,2 = L0231,2 bra LF5F8 ; send data ; ; $18 ; L00E6 Bit 2 = 1, X=177, A=C ;A=12 ;Bit 1 = 1, X=173, A=8 ;A=8 ;Bit 0 = 1, X=16F, D=0404 ;A=4 ldD L022D pshB ldaB #$02 staB L022E ;L022E = $02 decA ;A-1 ldaB #$01 staB L022D ;L022D = $01 popB ;B = ?? subB #$80 bcs LF6AB ;bra if B < 80 lslB ;B*2 ldX #$9765 ;X = 9765 aBX ;X + B ldX 0, X ;load X pushX ;save to stack tAB ;D = AA aBX ;X + A cmpY, #$022F aBY ;Y + B LF644: popA ;get from stack popB brclr, L004B, bit6&5&4&1, LF6AB ;send data brclr, L004B, bit6, LF680 pulB brclr, L004B, bit6&5&4&1, LF6B4 brclr, L004B, bit6, LF664 xgDX ;X = D LF658: ldaB 16, X ;B = ? xgDX ;+ LF65B: decX decY xgXY LF65F: ldaB 0, X xgXY cmpB 0, Y beq LF66E staB 0, X F668 03 E6 01 oim L00E6 ;SEEPROM data @ L016F, A=4? F66B 02 E6 EF aim L00E6 ;clr bit7 L00E6 cmpY #$022F LF672: bhi LF65B ;bra if Y > 022F ldaB #$01 ;B = 01 staB L022E ;L022E = 01 brset L004B, bit6, LF6A8 brclr L00E6, bit0, LF68C brset L004B, bit4|1, LF6A8 brset L004B, bit5, LF6A0 02 E6 FE aim L00E6 ;clr bit0 L00E6 LF68C: ldaB L004B andB #%00110010 ;test bits5,4,2 beq LF69B ;bra if L004B = $32 tBA oraA L0049 ;else staA L0049 ;L0049 = L0049|L004B oraB L004A staB L004A ;L004A = L004A|L004B aim L004B,#$8D ;clr L004B bit6,5,4,1 LF69E: bra LF6AB ; aim L00E6 ;clr bit0 L00E6 03 E6 02 oim L00E6 ;SEEPROM data @ L0173, A=8? bra LF6AB F6A8 03 E6 01 oim L00E6 ;SEEPROM data @ L016F, A=4? LF6AB: jmp LF5F8 ;send data ; ; ; $19 LF6AE: ldD L022D ;D = L022D,E pushB ;back up B ldaB #$02 staB L022E ;L022E = $02 decA ;dec A ldaB #$01 staB L022D ;L022D = $01 popB ;retore B subB #$80 bcs LF73C ;bra if B < 80 lslB ;B * 2 ldX #$9769 ;L9679 = 01 aBX ;X + B ldX 0, X tAB aBX ;X + B ldY #$022F ;Y = 022F aBY ;Y + B LF6D3: decX ;X-1 xgXY ; ldaB 0, Y xgXY cmpB 0, Y bne LF708 cmY,imm,y+ LF6E0: bhi LF6D1 ldaB #$01 staB L022E brclr L004B, bit0, LF6F9 oim L0049, bit0 oim L004A, bit0 aim L004C, bit0 aim L004B, bit0 LF6F7: bra LF73C brclr L004B, bit7, LF73F F6FD 03 49 08 oim F700 03 4A 08 oim F703 02 4B F7 aim bra LF739 F708 brclr 4B 01 23 F70C 03 49 01 oim F70F 02 4A FE aim F712 02 4C FE aim F715 02 4B FE aim LF718: ldaA #$FF tAB cpD #$022F bne LF73C cpd #$0231 bne LF73C ldaB #$01 staB L022E F72A 03 4C 01 bra LF73C F72F brclr 4B 08 0C F233 03 49 08 F236 02 4A F7 F739 02 4B F7 LF73C: jmp LF5F8 ;send contents of L022C LF73F: jmp LF3D4 ;clear registers and return ; ; ; ; ; ; ;Comes here when ECU fault flagged ;turn off outputs (High Z = low power) ;Force RAM reload on reset ;wait for interrupt ; ISR7: aim RAMCR, #$BF ;Reload RAM on restart clrA ;all port pins to high-z clrB stdD #00 ;clear L00 and L01 stdD #04 ;clear L04 and L05 staA P5DDR ;clear L15 wai ;wait for interrupt ; fill $FF, 2186 ; ; ; Reset and Interrupt Vectors ; ORG $FFD8 ; dw START ;FFD8 - dw ISR6 ;FFDA - SCI dw START ;FFDC dw START ;FFDE dw START ;FFE0 - dw START ;FFE2 - dw ISR3 ;FFE4 – RTI? dw START ;FFE6 - dw START ;FFE8 - dw START ;FFEA - dw ISR5 ;FFEC – OC3 dw ISR4 ;FFEE – OC2 dw START ;FFF0 – OC1 – confirmed? dw START ;FFF2 – ?? dw ISR2 ;FFF4 – IC2 dw ISR1 ;FFF6 – IC1 dw START ;FFF8 – Opcode? dw START ;FFFA – TOF – confirmed? dw ISR7 ;FFFC – NMI? dw START ;FFFE - Reset Vector End