NipponDenso.c

Go to the documentation of this file.

/* FreeEMS - the open source engine management system
 *
 * Copyright 2008, 2009, 2010 Fred Cooke
 *
 * This file is part of the FreeEMS project.
 *
 * FreeEMS software is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * FreeEMS software is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with any FreeEMS software.  If not, see http://www.gnu.org/licenses/
 *
 * We ask that if you make any changes to this file you email them upstream to
 * us at admin(at)diyefi(dot)org or, even better, fork the code on github.com!
 *
 * Thank you for choosing FreeEMS to run your engine!
 */


#include "inc/freeEMS.h"
#include "inc/interrupts.h"
#include "inc/DecoderInterface.h"
#include "inc/utils.h"


void PrimaryRPMISR(){
    /* Clear the interrupt flag for this input compare channel */
    TFLG = 0x01;

    /* Save all relevant available data here */
    unsigned short codeStartTimeStamp = TCNT;       /* Save the current timer count */
    unsigned short edgeTimeStamp = TC0;             /* Save the edge time stamp */
    unsigned char PTITCurrentState = PTIT;          /* Save the values on port T regardless of the state of DDRT */
//  unsigned short PORTS_BACurrentState = PORTS_BA; /* Save ignition output state */

    /* Calculate the latency in ticks */
    ISRLatencyVars.primaryInputLatency = codeStartTimeStamp - edgeTimeStamp;

    /* The LM1815 variable reluctance sensor amplifier allows the output to be
     * pulled high starting at the center of a tooth. So, what we see as the
     * start of a tooth is actually the centre of a physical tooth. Because
     * tooth shape, profile and spacing may vary this is the only reliable edge
     * for us to schedule from, hence the trailing edge code is very simple.
     */
    if(PTITCurrentState & 0x01){
        /* Echo input condition on J7 */
        PORTJ |= 0x80;

        // increment crank pulses TODO this needs to be wrapped in tooth period and width checking
        primaryPulsesPerSecondaryPulse++;

        // calculate rough rpm (this will be wrong when the var is used correctly)
        *RPMRecord = ticksPerCycleAtOneRPMx2 / engineCyclePeriod; /* 0.8us ticks, 150mil = 2 x 60 seconds, times rpm scale factor of 2 */

        // don't run until the second trigger has come in and the period is correct (VERY temporary)
        if(!(coreStatusA & PRIMARY_SYNC)){
            primaryTeethDroppedFromLackOfSync++;
            return;
        }

        LongTime timeStamp;

        /* Install the low word */
        timeStamp.timeShorts[1] = edgeTimeStamp;
        /* Find out what our timer value means and put it in the high word */
        if(TFLGOF && !(edgeTimeStamp & 0x8000)){ /* see 10.3.5 paragraph 4 of 68hc11 ref manual for details */
            timeStamp.timeShorts[0] = timerExtensionClock + 1;
        }else{
            timeStamp.timeShorts[0] = timerExtensionClock;
        }

        // temporary data from inputs
        primaryLeadingEdgeTimeStamp = timeStamp.timeLong;
        timeBetweenSuccessivePrimaryPulses = lastPrimaryPulseTimeStamp - primaryLeadingEdgeTimeStamp;
        lastPrimaryPulseTimeStamp = primaryLeadingEdgeTimeStamp;
//      timeBetweenSuccessivePrimaryPulsesBuffer = (timeBetweenSuccessivePrimaryPulses >> 1) + (timeBetweenSuccessivePrimaryPulsesBuffer >> 1);

        // TODO make scheduling either fixed from boot with a limited range, OR preferrably if its practical scheduled on the fly to allow arbitrary advance and retard of both fuel and ignition.

        /* Check for loss of sync by too high a count */
        if(primaryPulsesPerSecondaryPulse > 12){
            /* Increment the lost sync count */
            Counters.crankSyncLosses++;

            /* Clear synced status */
            coreStatusA &= CLEAR_PRIMARY_SYNC;

            /* Reset the count of teeth */
            primaryPulsesPerSecondaryPulse = 0;

            /* Get the hell out of here before we do something bad */
            return;
        }

        // CAUTION came to me lying in bed half asleep idea :

        // TODO move tooth selection to the calc loop in main such that this routine just iterates through an array of events and schedules those that are destined for this tooth.

        // if ign enabled
            // iterate through ignition first, schedule all of those
            // iterate through dwell next, schedule all of those
        // if fuel enabled
            // iterate through main fuel next, schedule all of those
            // if staging enabled and required
                // iterate through staged fuel last,

        // TODO should make for a clean compact scheduling implementation. the fuel code doesn't care when/how it has started in the past, and hopefully ign will be the same.

        // this will be done with an array and per tooth check in future
        if((primaryPulsesPerSecondaryPulse % 2) == 0){

            // TODO sample ADCs on teeth other than that used by the scheduler in order to minimise peak run time and get clean signals
            sampleEachADC(ADCArrays);
            Counters.syncedADCreadings++;
            *mathSampleTimeStampRecord = TCNT;

            /* Set flag to say calc required */
            coreStatusA |= CALC_FUEL_IGN;

            /* Reset the clock for reading timeout */
            Clocks.timeoutADCreadingClock = 0;

            if(masterPulseWidth > injectorMinimumPulseWidth){ // use reference PW to decide. spark needs moving outside this area though TODO
                /* Determine if half the cycle is bigger than short-max */
                unsigned short maxAngleAfter;
                if((engineCyclePeriod >> 1) > 0xFFFF){
                    maxAngleAfter = 0xFFFF;
                }else{
                    maxAngleAfter = (unsigned short)(engineCyclePeriod >> 1);
                }

                /* Check advance to ensure it is less than 1/2 of the previous engine cycle and more than codetime away */
                unsigned short advance;
                if(totalAngleAfterReferenceInjection > maxAngleAfter){ // if too big, make it max
                    advance = maxAngleAfter;
                }else if(totalAngleAfterReferenceInjection < trailingEdgeSecondaryRPMInputCodeTime){ // if too small, make it min
                    advance = trailingEdgeSecondaryRPMInputCodeTime;
                }else{ // else use it as is
                    advance = totalAngleAfterReferenceInjection;
                }

                // determine the long and short start times
                unsigned short startTime = primaryLeadingEdgeTimeStamp + advance;
                unsigned long startTimeLong = timeStamp.timeLong + advance;

                /* Determine the channels to schedule */
                unsigned char fuelChannel = (primaryPulsesPerSecondaryPulse / 2) - 1;
                unsigned char ignitionChannel = (primaryPulsesPerSecondaryPulse / 2) - 1;

                if(fuelChannel > 5 || ignitionChannel > 5){
//                  send("bad fuel : ");
    //              sendUC(fuelChannel);
        //          send("bad  ign : ");
            //      sendUC(ignitionChannel);
                    return;
                }

                // determine whether or not to reschedule
                unsigned char reschedule = 0;
                unsigned long diff = startTimeLong - (injectorMainEndTimes[fuelChannel] + injectorSwitchOffCodeTime);
                if(diff > LONGHALF){
                    reschedule = 1; // http://www.diyefi.org/forum/viewtopic.php?f=8&t=57&p=861#p861
                }

                // schedule the appropriate channel
                if(!(*injectorMainControlRegisters[fuelChannel] & injectorMainEnableMasks[fuelChannel]) || reschedule){ /* If the timer isn't still running, or if its set too long, set it to start again at the right time soon */
                    *injectorMainControlRegisters[fuelChannel] |= injectorMainEnableMasks[fuelChannel];
                    *injectorMainTimeRegisters[fuelChannel] = startTime;
                    TIE |= injectorMainOnMasks[fuelChannel];
                    TFLG = injectorMainOnMasks[fuelChannel];
                }else{
                    injectorMainStartTimesHolding[fuelChannel] = startTime;
                    selfSetTimer |= injectorMainOnMasks[fuelChannel]; // setup a bit to let the timer interrupt know to set its own new start from a var
                }

                // TODO advance/retard/dwell numbers all need range checking etc done. some of this should be done in the calculator section, and some here. currently none is done at all and for that reason, this will not work in a real system yet, if it works at all.
                // as do array indexs here and in the ISRs...


                // TODO implement mechanism for dropping a cylinder in event of over queueing or spark cut/round robin
                // important as ignition sequence disrupted when this occurs as it stands.

                // TODO check queue length checks to ensure we dont count up to somewhere we can never count down from. This could be causing the hanging long phenomina

                // DWELL

                // If dwell is not currently enabled, set it all up
                if(!(PITCE & DWELL_ENABLE)){
                    /* Schedule Dwell event (do this first because it comes earliest. */
                    // set the channel to fire
                    nextDwellChannel = ignitionChannel;

                    // set the time
                    PITLD0 = advance;
                    //              PITLD0 = ignitionAdvances[ignitionChannel] - *currentDwellRealtime; BAD for various reasons!

                    // clear the flags first as they apparently become set any old time whether enabled or not.
                    PITTF |= DWELL_ENABLE;

                    // turn on the ints
                    PITINTE |= DWELL_ENABLE;

                    // clear the flags first as they apparently become set any old time whether enabled or not.
                    PITTF |= DWELL_ENABLE;

                    // enable channels
                    PITCE |= DWELL_ENABLE;
                }else if(dwellQueueLength == 0){
                    // load time offset such that next period is correct
                    PITLD0 = (advance - PITCNT0);

                    // increment queue length
                    dwellQueueLength++;
                }else if(dwellQueueLength > fixedConfigs1.engineSettings.combustionEventsPerEngineCycle){ //TODO sensible figures here for array index OOBE
                    // do nothing, or increment a counter or something similar.
                }else{
                    unsigned short sumOfDwells = PITLD0;
                    // add up the prequeued time periods

                    // queue = 1 pitld is all
                    // queue = 2 one from 0 index of array AND pitld

                    unsigned char index = 0;
                    while(index < (dwellQueueLength -1)){
                        sumOfDwells += queuedDwellOffsets[index];
                        index++;
                    }
                    //              for(index = 0;index < (dwellQueueLength -1);index++){ // is this right?
                    //                  sumOfDwells += queuedDwellOffsets[index];
                    //              }

                    // store time offset in appropriate array location
                    queuedDwellOffsets[dwellQueueLength - 1] = advance - (PITCNT0 + sumOfDwells);

                    // increment queue length from one or more
                    dwellQueueLength++;
                }

                // IGNITION experimental stuff

                // If ignition is not currently enabled, set it all up
                if(!(PITCE & IGNITION_ENABLE)){
                    /* Schedule Ignition event (do this first because it comes earliest. */
                    // set the channel to fire
                    nextIgnitionChannel = ignitionChannel;

                    // figure out the time to set the delay reg to
                    PITLD1 = advance + injectorMainPulseWidthsRealtime[fuelChannel];
                    //              PITLD1 = ignitionAdvances[ignitionChannel + outputBankIgnitionOffset];

                    // clear the flags first as they apparently become set any old time whether enabled or not.
                    PITTF |= IGNITION_ENABLE;

                    // turn on the ints
                    PITINTE |= IGNITION_ENABLE;

                    // clear the flags first as they apparently become set any old time whether enabled or not.
                    PITTF |= IGNITION_ENABLE;

                    // enable channels
                    PITCE |= IGNITION_ENABLE;
                }else if(ignitionQueueLength == 0){
                    // load timer register
                    PITLD1 = ((advance + injectorMainPulseWidthsRealtime[fuelChannel]) - PITCNT1);

                    // increment to 1
                    ignitionQueueLength++;
                }else if(ignitionQueueLength > fixedConfigs1.engineSettings.combustionEventsPerEngineCycle){ //TODO sensible figures here for array index OOBE
                    // do nothing, or increment a counter or something similar.
                }else{
                    unsigned short sumOfIgnitions = PITLD1;
                    // add up the prequeued time periods

                    // queue = 1 pitld is all
                    // queue = 2 one from 0 index of array AND pitld


                    unsigned char index = 0;
                    while(index < (ignitionQueueLength - 1)){
                        sumOfIgnitions += queuedIgnitionOffsets[index];
                        index++;
                    }
                    //  for(index = 0;index < (ignitionQueueLength -1);index++){ // is this right?
                    //      sumOfIgnitions += queuedIgnitionOffsets[index];
                    //  }

                    // store time offset in appropriate array location
                    queuedIgnitionOffsets[ignitionQueueLength - 1] = advance - (PITCNT1 + sumOfIgnitions);

                    // increment from 1 or more
                    ignitionQueueLength++;
                }
            }
        }
        RuntimeVars.primaryInputLeadingRuntime = TCNT - codeStartTimeStamp;
    }else{
        PORTJ &= 0x7F;
        RuntimeVars.primaryInputTrailingRuntime = TCNT - codeStartTimeStamp;
    }

    Counters.primaryTeethSeen++;
    // suss out rpm and accurate TDC reference

    // if you say it quick, it doesn't sound like much :
    // schedule fuel and ign based on spark cut and fuel cut and timing vars and status vars config vars
}


void SecondaryRPMISR(){
    /* Clear the interrupt flag for this input compare channel */
    TFLG = 0x02;

    /* Save all relevant available data here */
    unsigned short codeStartTimeStamp = TCNT;       /* Save the current timer count */
    unsigned short edgeTimeStamp = TC1;             /* Save the timestamp */
    unsigned char PTITCurrentState = PTIT;          /* Save the values on port T regardless of the state of DDRT */
//  unsigned short PORTS_BACurrentState = PORTS_BA; /* Save ignition output state */

    /* Calculate the latency in ticks */
    ISRLatencyVars.secondaryInputLatency = codeStartTimeStamp - edgeTimeStamp;

    /* The LM1815 variable reluctance sensor amplifier allows the output to be
     * pulled high starting at the center of a tooth. So, what we see as the
     * start of a tooth is actually the centre of a physical tooth. Because
     * tooth shape, profile and spacing may vary this is the only reliable edge
     * for us to schedule from, hence the trailing edge code is very simple.
     */
    if(PTITCurrentState & 0x02){
        // echo input condition
        PORTJ |= 0x40;

        // display the crank pulses
        PORTM = (char)primaryPulsesPerSecondaryPulse;

// was this code like this because of a good reason?
//      primaryPulsesPerSecondaryPulseBuffer = primaryPulsesPerSecondaryPulse;
        primaryPulsesPerSecondaryPulse = 0;

        // if we didn't get the right number of pulses drop sync and start over
        if((primaryPulsesPerSecondaryPulse != 12) && (coreStatusA & PRIMARY_SYNC)){
            coreStatusA &= CLEAR_PRIMARY_SYNC;
            Counters.crankSyncLosses++;
        }

        LongTime timeStamp;

        /* Install the low word */
        timeStamp.timeShorts[1] = edgeTimeStamp;
        /* Find out what our timer value means and put it in the high word */
        if(TFLGOF && !(edgeTimeStamp & 0x8000)){ /* see 10.3.5 paragraph 4 of 68hc11 ref manual for details */
            timeStamp.timeShorts[0] = timerExtensionClock + 1;
        }else{
            timeStamp.timeShorts[0] = timerExtensionClock;
        }

        // get the data we actually want
        engineCyclePeriod = 2 * (timeStamp.timeLong - lastSecondaryOddTimeStamp); // save the engine cycle period
        lastSecondaryOddTimeStamp = timeStamp.timeLong; // save this stamp for next time round

        // Because this is our only reference, each time we get this pulse, we know where we are at (simple mode so far)
        coreStatusA |= PRIMARY_SYNC;
        RuntimeVars.secondaryInputLeadingRuntime = TCNT - codeStartTimeStamp;
    }else{
        PORTJ &= 0xBF;
        RuntimeVars.secondaryInputTrailingRuntime = TCNT - codeStartTimeStamp;
    }

    Counters.secondaryTeethSeen++;
    // suss out phase/engine cycle reference showing which bank we are on

    /* If the flag is not cleared at the beginning then the interrupt gets rescheduled while it is running, hence it can't be done at the end of the ISR */
}

---