interrupts.h File Reference

All interrupt handler declarations. More...

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Defines
#define	INT   __attribute__((interrupt))
#define	ATOMIC_START()   __asm__ __volatile__ ("sei")
#define	ATOMIC_END()   __asm__ __volatile__ ("cli")
#define	VECTORS   __attribute__ ((section (".vectors")))
Typedefs
typedef void(*	interruptTable )(void)
Functions
void	_start (void)
void	UISR (void) INT TEXT1
	Unimplemented Interrupt Handler.
void	Injector1ISR (void) INT TEXT1
	Injector1ISR is expanded from InjectorXISR via include statement, and macro definition(s).
void	Injector2ISR (void) INT TEXT1
	Injector2ISR is expanded from InjectorXISR via include statement, and macro definition(s).
void	Injector3ISR (void) INT TEXT1
	Injector3ISR is expanded from InjectorXISR via include statement, and macro definition(s).
void	Injector4ISR (void) INT TEXT1
	Injector4ISR is expanded from InjectorXISR via include statement, and macro definition(s).
void	Injector5ISR (void) INT TEXT1
	Injector5ISR is expanded from InjectorXISR via include statement, and macro definition(s).
void	Injector6ISR (void) INT TEXT1
	Injector6ISR is expanded from InjectorXISR via include statement, and macro definition(s).
void	PrimaryRPMISR (void) INT TEXT1
void	SecondaryRPMISR (void) INT TEXT1
	Use the rising and falling edges...................
void	TimerOverflow (void) INT TEXT1
	ECT overflow handler.
void	ModDownCtrISR (void) INT TEXT1
	Tacho pulse generator.
void	IgnitionDwellISR (void) INT TEXT1
	Ignition dwell control.
void	IgnitionFireISR (void) INT TEXT1
	Ignition discharge control.
void	StagedOnISR (void) INT TEXT1
void	StagedOffISR (void) INT TEXT1
void	PortPISR (void) INT TEXT1
	Port P pins ISR.
void	PortHISR (void) INT TEXT1
	Port H pins ISR.
void	PortJISR (void) INT TEXT1
	Port J pins ISR.
void	IRQISR (void) INT TEXT1
	IRQ/PE1 pin ISR.
void	XIRQISR (void) INT TEXT1
	XIRQ/PE0 pin ISR.
void	RTIISR (void) INT TEXT1
	Real Time Interrupt Handler.
void	SCI0ISR (void) INT TEXT1
	Serial Communication Interface 0 ISR.
void	LowVoltageISR (void) INT TEXT1
	Low Voltage Counter.
void	VRegAPIISR (void) INT TEXT1

---

Detailed Description

All interrupt handler declarations.

All of the declarations for ISR functions are done here because they are all used in one place and it doesn't make sense to spread them out over N files for N functions. ISR headers only exist where there is a requirement for local variables and constants etc.

Author:

Fred Cooke

Definition in file interrupts.h.

---

Define Documentation

 

#define ATOMIC_END

(

)

__asm__ __volatile__ ("cli")

Definition at line 61 of file interrupts.h.

Referenced by init(), and main().

 

#define ATOMIC_START

(

)

__asm__ __volatile__ ("sei")

Definition at line 60 of file interrupts.h.

Referenced by init(), and main().

#define INT   __attribute__((interrupt))

Definition at line 53 of file interrupts.h.

#define VECTORS   __attribute__ ((section (".vectors")))

Definition at line 64 of file interrupts.h.

---

Typedef Documentation

typedef void(* interruptTable)(void)

Definition at line 107 of file interrupts.h.

---

Function Documentation

void _start

(

void

)

Referenced by decodePacketAndRespond().

void IgnitionDwellISR

(

void

)

Ignition dwell control.

This function turns ignition pins on to dwell when required.

Author:

Fred Cooke

Todo:

TODO make this actually work.

Definition at line 73 of file ignitionISRs.c.

References engineSetting::combustionEventsPerEngineCycle, DWELL_DISABLE, DWELL_ENABLE, dwellQueueLength, dwellStartMasks, fixedConfig1::engineSettings, fixedConfigs1, nextDwellChannel, PITCE, PITINTE, PITLD0, PITTF, PORTS, PORTS_BA, and queuedDwellOffsets.

{
    // clear flag
    PITTF = DWELL_ENABLE;

    // start dwelling asap
    PORTS_BA |= dwellStartMasks[nextDwellChannel];

    if(dwellQueueLength == 0){
        // turn off the int
        PITINTE &= DWELL_DISABLE;

        // disable channels
        PITCE &= DWELL_DISABLE;
    }else{
        // reduce queue length by one
        dwellQueueLength--;

        // increment channel counter to next channel
        if(nextDwellChannel < (fixedConfigs1.engineSettings.combustionEventsPerEngineCycle - 1)){
            nextDwellChannel++; // if not the last channel, increment
        }else{
            nextDwellChannel = 0; // if the last channel, reset to zero
        }

        // if the queue length after decrement is greater than 0 then we need to load the timer, if it is zero and we decremented, the timer was already loaded.
        if(dwellQueueLength > 0){
            if(dwellQueueLength > 8){ // TODO ???? why 8 ???? 12 or combustion events per... or ?
                //throw a nasty error of some sort for index out of range issue that should never occur (for now just light a LED)
                PORTS |= 0x20;
            }else{
                // load the timer if the index is good
                PITLD0 = queuedDwellOffsets[dwellQueueLength - 1];
            }
        }
    }

    // blink a led
    PORTS ^= 0x80;
}

void IgnitionFireISR

(

void

)

Ignition discharge control.

This function turns ignition pins off to discharge when required.

Author:

Fred Cooke

Todo:

TODO make this actually work.

Definition at line 123 of file ignitionISRs.c.

References engineSetting::combustionEventsPerEngineCycle, fixedConfig1::engineSettings, fixedConfigs1, IGNITION_DISABLE, IGNITION_ENABLE, ignitionMasks, ignitionQueueLength, nextIgnitionChannel, PITCE, PITINTE, PITLD0, PITTF, PORTS, PORTS_BA, and queuedIgnitionOffsets.

{
    // clear flag
    PITTF = IGNITION_ENABLE;

    // fire the coil asap
    PORTS_BA &= ignitionMasks[nextIgnitionChannel];

    if(ignitionQueueLength == 0){
        // turn off the int
        PITINTE &= IGNITION_DISABLE;

        // disable channels
        PITCE &= IGNITION_DISABLE ;
    }else{
        // reduce queue length by one
        ignitionQueueLength--;

        // increment channel counter to next channel
        if(nextIgnitionChannel < (fixedConfigs1.engineSettings.combustionEventsPerEngineCycle - 1)){
            nextIgnitionChannel++; // if not the last channel, increment
        }else{
            nextIgnitionChannel = 0; // if the last channel, reset to zero
        }

        // if the queue length after decrement is greater than 0 then we need to load the timer, if it is zero and we decremented, the timer was already loaded.
        if(ignitionQueueLength > 0){
            if(ignitionQueueLength > fixedConfigs1.engineSettings.combustionEventsPerEngineCycle){ // TODO as above!!!!!!!!!!
                //throw a nasty error of some sort for index out of range issue that should never occur (for now just light a LED)
                PORTS |= 0x10;
            }else{
                // load the timer if the index is good
                PITLD0 = queuedIgnitionOffsets[ignitionQueueLength - 1];
            }
        }
    }

    // blink a led
    PORTS ^= 0x40;
}

void Injector1ISR

(

void

)

Injector1ISR is expanded from InjectorXISR via include statement, and macro definition(s).

void Injector2ISR

(

void

)

Injector2ISR is expanded from InjectorXISR via include statement, and macro definition(s).

void Injector3ISR

(

void

)

Injector3ISR is expanded from InjectorXISR via include statement, and macro definition(s).

void Injector4ISR

(

void

)

Injector4ISR is expanded from InjectorXISR via include statement, and macro definition(s).

void Injector5ISR

(

void

)

Injector5ISR is expanded from InjectorXISR via include statement, and macro definition(s).

void Injector6ISR

(

void

)

Injector6ISR is expanded from InjectorXISR via include statement, and macro definition(s).

void IRQISR

(

void

)

IRQ/PE1 pin ISR.

Interrupt handler for edge events on the IRQ/PE1 pin. Not currently used.

Author:

Fred Cooke

Definition at line 203 of file miscISRs.c.

References Counter::callsToUISRs, and Counters.

                 {
    /* Clear the flag */
    // ?? TODO

    /* Increment the unimplemented ISR execution counter */
    Counters.callsToUISRs++;
}

void LowVoltageISR

(

void

)

Low Voltage Counter.

Count how often our voltage drops lower than it should without resetting.

Author:

Fred Cooke

Definition at line 233 of file miscISRs.c.

References Counters, Counter::lowVoltageConditions, and VREGCTRL.

                        {
    /* Clear the flag */
    VREGCTRL |= 0x01;

    /* Increment the counter */
    Counters.lowVoltageConditions++;
}

void ModDownCtrISR

(

void

)

Tacho pulse generator.

Currently this is being used to generate a variable frequency tachometer output. Although this is a bit of a waste of a timer resource it does allow tachometers that were intended for engines with a different cylinder count to be used where it would otherwise not be possible.

Author:

Fred Cooke

Definition at line 149 of file realtimeISRs.c.

References engineCyclePeriod, fixedConfigs1, MCCNT, MCFLG, PORTA, tachoPeriod, fixedConfig1::tachoSettings, tachoSetting::tachoTotalFactor, and ticksPerCycleAtOneRPM.

                    {
    /* Clear the modulus down counter interrupt flag */
    MCFLG = 0x80;

    /* If the rpm isn't genuine go ultra slow */
    if(engineCyclePeriod == ticksPerCycleAtOneRPM){
        tachoPeriod = 65535;
    }else{
        /* Use engine cycle period to setup the frequency of this counter and thereby act as a tacho out */
        tachoPeriod = (unsigned long)engineCyclePeriod / fixedConfigs1.tachoSettings.tachoTotalFactor;
    }
    /* Set the count down value */
    MCCNT = tachoPeriod;

    /* Bit bang the output port */
    PORTA ^= 0x40; // SM pin (A6)
}

void PortHISR

(

void

)

Port H pins ISR.

Interrupt handler for edge events on port H pins. Not currently used.

Author:

Fred Cooke

Definition at line 90 of file miscISRs.c.

References ONES, PIFH, PORTA, and portHDebounce.

{
//  // read the interrupt flags to a variable
//  unsigned char portHFlags = PIFH;
//  portHFlags &= 0xF8; // mask out the other bits
//
//  /* Clear all port H flags (we only want one at a time) */
    PIFH = ONES;
//
//  // Toggle a LED so we can see if the code ran
    PORTA ^= 0x80; // Fuel pump pin (A7)
//
    // debounce
    if(portHDebounce == 0){
        portHDebounce = 2;
    }else{
        return;
    }
//
//  // find out which pin triggered it, clear the flag, perform the action.
//  switch(portHFlags)
//  {
//  case 0x80 : // Increment cylinder count and set port count appropriately.
//      switch (configs.combustionEventsPerEngineCycle) {
//          case 1 :
//              configs.combustionEventsPerEngineCycle = 2;
//              configs.ports = 2;
//              break;
//          case 2 :
//              configs.combustionEventsPerEngineCycle = 3;
//              configs.ports = 3;
//              break;
//          case 3 :
//              configs.combustionEventsPerEngineCycle = 4;
//              configs.ports = 4;
//              break;
//          case 4 :
//              configs.combustionEventsPerEngineCycle = 5;
//              configs.ports = 5;
//              break;
//          case 5 :
//              configs.combustionEventsPerEngineCycle = 6;
//              configs.ports = 6;
//              break;
//          case 6 :
//              configs.combustionEventsPerEngineCycle = 8;
//              configs.ports = 4;
//              break;
//          case 8 :
//              configs.combustionEventsPerEngineCycle = 10;
//              configs.ports = 5;
//              break;
//          case 10 :
//              configs.combustionEventsPerEngineCycle = 12;
//              configs.ports = 6;
//              break;
//          case 12 :
//              configs.combustionEventsPerEngineCycle = 1;
//              configs.ports = 1;
//              break;
//      }
//      break;
//  case 0x40 : // Injection output enable/disable
//      if(coreSettingsA & FUEL_CUT){
//          coreSettingsA &= FUEL_CUT_OFF;
//      }else{
//          coreSettingsA |= FUEL_CUT;
//      }
//      break;
//  case 0x20 : // Ignition output enable/disable
//      if(coreSettingsA & HARD_SPARK_CUT){
//          coreSettingsA &= HARD_SPARK_CUT_OFF;
//      }else{
//          coreSettingsA |= HARD_SPARK_CUT;
//      }
//      break;
//  case 0x10 : // Staged injection enable/disable
//      if(coreSettingsA & STAGED_ON){
//          coreSettingsA &= STAGED_OFF;
//      }else{
//          coreSettingsA |= STAGED_ON;
//      }
//      break;
//  case 0x08 : // Staged injection start sched/fixed
//      if(coreSettingsA & STAGED_START){
//          coreSettingsA &= CLEAR_STAGED_START;
//      }else{
//          coreSettingsA |= STAGED_START;
//      }
//      break;
//  case 0x04 : // Staged injection end sched/fixed
//      if(coreSettingsA & STAGED_END){
//          coreSettingsA &= CLEAR_STAGED_END;
//      }else{
//          coreSettingsA |= STAGED_END;
//      }
//      break;
//  case 0x02 : // free input
//      break;
//  case 0x01 : // free input
//      break;
//  default : // Two or more pressed, nothing to do except wait for another button press
//      break;
//  }
}

void PortJISR

(

void

)

Port J pins ISR.

Interrupt handler for edge events on port J pins. Not currently used.

Author:

Fred Cooke

Definition at line 76 of file miscISRs.c.

References Counter::callsToUISRs, Counters, ONES, and PIFJ.

                   {
    /* Clear all port H flags (we only want one at a time) */
    PIFJ = ONES;
    /* Increment the unimplemented ISR execution counter */
    Counters.callsToUISRs++;
}

void PortPISR

(

void

)

Port P pins ISR.

Interrupt handler for edge events on port P pins. Not currently used.

Author:

Fred Cooke

Definition at line 62 of file miscISRs.c.

References Counter::callsToUISRs, Counters, ONES, and PIFP.

                   {
    /* Clear all port P flags (we only want one at a time) */
    PIFP = ONES;
    /* Increment the unimplemented ISR execution counter */
    Counters.callsToUISRs++;
}           /* Port P interrupt service routine */

void PrimaryRPMISR

(

void

)

Primary RPM ISR

Todo:

TODO Docs here!

Primary RPM ISR

Todo:

TODO Docs here!

Primary RPM ISR

Todo:

TODO Docs here!

Primary RPM ISR

Summary of intended engine position capture scheme (out of date as at 3/1/09)

Position/RPM signal interpretation : Discard edges that have arrived too soon (lose sync here?) Check to ensure we haven't lost sync (pulse arrives too late) Compare time stamps of successive edges and calculate RPM Store RPM and position in globals

Schedule events : loop through all events (spark and fuel), schedule those that fall sufficiently after this tooth and before the next one we expect.

Sample ADCs : Grab a unified set of ADC readings at one time in a consistent crank location to eliminate engine cycle dependent noise. Set flag stating that New pulse, advance, etc should be calculated.

Author:

Fred Cooke

Warning:

These are for testing and demonstration only, not suitable for driving with just yet.

Todo:

TODO bring the above docs up to date with reality

Todo:

TODO finish this off to a usable standard

Primary RPM ISR

Schedule events : Blindly start fuel pulses for each and every input pulse.

Sample ADCs : Grab a unified set of ADC readings at one time in a consistent crank location to eliminate engine cycle dependent noise. Set flag stating that New pulse, advance, etc should be calculated.

Author:

Fred Cooke

Warning:

These are for testing and demonstration only, not suitable for driving with just yet.

Todo:

TODO make this code more general and robust such that it can be used for real simple applications

Primary RPM ISR

Todo:

TODO Docs here!

Todo:

TODO discard narrow ones! test for tooth width and tooth period the width should be based on how the hardware is setup. IE the LM1815 is adjusted to have a pulse output of a particular width. This noise filter should be matched to that width as should the hardware filter.

Definition at line 71 of file LT1-360-8.c.

References ADCArrays, CALC_FUEL_IGN, CLEAR_PRIMARY_SYNC, Clocks, engineSetting::combustionEventsPerEngineCycle, fixedConfig1::coreSettingsA, coreStatusA, Counters, Counter::crankSyncLosses, DWELL_ENABLE, dwellQueueLength, engineCyclePeriod, fixedConfig1::engineSettings, fixedConfigs1, IGNITION_ENABLE, ignitionQueueLength, injectorMainControlRegisters, injectorMainEnableMasks, injectorMainEndTimes, injectorMainOnMasks, injectorMainPulseWidthsRealtime, injectorMainStartTimesHolding, injectorMainTimeRegisters, injectorMinimumPulseWidth, injectorSwitchOffCodeTime, ISRLatencyVars, isSynced, lastPrimaryPulseTimeStamp, LONGHALF, masterPulseWidth, mathSampleTimeStampRecord, nextDwellChannel, nextIgnitionChannel, PITCE, PITCNT0, PITCNT1, PITINTE, PITLD0, PITLD1, PITTF, PORTJ, PORTP, PRIMARY_POLARITY, PRIMARY_SYNC, ISRLatencyVar::primaryInputLatency, RuntimeVar::primaryInputLeadingRuntime, RuntimeVar::primaryInputTrailingRuntime, primaryLeadingEdgeTimeStamp, primaryPulsesPerSecondaryPulse, primaryTeethDroppedFromLackOfSync, PrimaryTeethDuringHigh, PrimaryTeethDuringLow, Counter::primaryTeethSeen, PTIT, queuedDwellOffsets, queuedIgnitionOffsets, RPMRecord, RuntimeVars, sampleEachADC(), selfSetTimer, Counter::syncedADCreadings, TC0, TCNT, TFLG, TFLGOF, ticksPerCycleAtOneRPMx2, ticksPerMinute, TIE, timeBetweenSuccessivePrimaryPulses, LongTime::timeLong, Clock::timeoutADCreadingClock, timerExtensionClock, LongTime::timeShorts, totalAngleAfterReferenceInjection, trailingEdgeSecondaryRPMInputCodeTime, and VCAS.

                        {
    /* 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 */

//  unsigned char risingEdge; /* in LT1s case risingEdge means signal is high */
//  if(fixedConfigs1.coreSettingsA & PRIMARY_POLARITY){
//      risingEdge = PTITCurrentState & 0x01;
//  }else{
//      risingEdge = !(PTITCurrentState & 0x01);
//  }

    PORTJ |= 0x80; /* Echo input condition on J7 */
    if(!isSynced){  /* If the CAS is not in sync get window counts so SecondaryRPMISR can set position */
        if (PTITCurrentState & 0x02){
            PrimaryTeethDuringHigh++;  /* if low resolution signal is high count number of pulses */
        }else{
            PrimaryTeethDuringLow++;  /* if low resolution signal is low count number of pulses */
        }
    }else{  /* The CAS is synced and we need to update our 360/5=72 tooth wheel */
        VCAS = VCAS + 10;  /* Check/correct for 10deg of CAM movement */
    }
}

Here is the call graph for this function:

void RTIISR

(

void

)

Real Time Interrupt Handler.

Handles time keeping, including all internal clocks, and generic periodic tasks that run quickly and must be done on time.

Author:

Fred Cooke

Definition at line 53 of file realtimeISRs.c.

References Clocks, coreStatusA, CRGFLG, fixedConfigs2, FORCE_READING, Clock::millisToTenths, portHDebounce, sensorSetting::readingTimeout, Clock::realTimeClockMain, Clock::realTimeClockMillis, Clock::realTimeClockMinutes, Clock::realTimeClockSeconds, Clock::realTimeClockTenths, RuntimeVar::RTCRuntime, RuntimeVars, Clock::secondsToMinutes, fixedConfig2::sensorSettings, ShouldSendLog, TCNT, Clock::tenthsToSeconds, Clock::timeoutADCreadingClock, and TRUE.

             {
    /* Clear the RTI flag */
    CRGFLG = 0x80;

    /* Record time stamp for code run time reporting */
    unsigned short startTimeRTI = TCNT;

    /* Increment the counter */
    Clocks.realTimeClockMain++;

    /* This function could be performed without the extra variables by rolling over the main ones at the largest multiples of the next ones, but I'm not sure thats better */

    // TODO add content to eighths of a milli RTC ?

    /* Every 8th RTI execution is one milli */
    if(Clocks.realTimeClockMain % 8 == 0){
        /* Increment the milli counter */
        Clocks.realTimeClockMillis++;

        /* Increment the milli roll over variable */
        Clocks.millisToTenths++;

        /* Perform all tasks that are once per millisecond here or preferably main */
        Clocks.timeoutADCreadingClock++;
        if(Clocks.timeoutADCreadingClock > fixedConfigs2.sensorSettings.readingTimeout){
            /* Set force read adc flag */
            coreStatusA |= FORCE_READING;
            Clocks.timeoutADCreadingClock = 0;
        }

        /* Every 100 millis is one tenth */
        if(Clocks.millisToTenths % 100 == 0){
            /* Increment the tenths counter */
            Clocks.realTimeClockTenths++;

            /* Increment the tenths roll over variable */
            Clocks.tenthsToSeconds++;

            /* Reset the millis roll over variable */
            Clocks.millisToTenths = 0;

            /* Perform all tasks that are once per tenth of a second here or preferably main */
            // decrement port H debounce variable till it's zero again.
            if(portHDebounce != 0){
                portHDebounce -= 1;
            }

            /* Every 10 tenths is one second */
            if(Clocks.tenthsToSeconds % 10 == 0){
                /* Increment the seconds counter */
                Clocks.realTimeClockSeconds++;

                /* Increment the seconds roll over variable */
                Clocks.secondsToMinutes++;

                /* Reset the tenths roll over variable */
                Clocks.tenthsToSeconds = 0;
                /* Perform all tasks that are once per second here or preferably main */

                // temp throttling for log due to tuner performance issues (in the bedroom)
                ShouldSendLog = TRUE;
                /* Flash the user LED as a "heartbeat" to let new users know it's alive */
                //PORTP ^= 0x80;

                /* Every 60 seconds is one minute, 65535 minutes is enough for us :-) */
                if(Clocks.secondsToMinutes % 60 == 0){
                    /* Increment the minutes counter */
                    Clocks.realTimeClockMinutes++;

                    /* Potentially put an hours field in here and below, but that would be excessive */
                    // TODO add hours RTC ?

                    /* Reset the seconds roll over variable */
                    Clocks.secondsToMinutes = 0;

                    /* Perform all tasks that are once per minute here or preferably main */
                    // TODO add content in minutes RTC ?

                    /* Hours if statement here if we do hours which we probably won't */
                }
            }
        }
    }
    RuntimeVars.RTCRuntime = TCNT - startTimeRTI;
}

void SCI0ISR

(

void

)

Serial Communication Interface 0 ISR.

SCI0 ISR handles all interrupts for SCI0 by reading flags and acting appropriately. Its functions are to send raw bytes out over the wire from a buffer and to receive bytes from the wire un-escape them, checksum them and store them in a buffer.

Author:

Fred Cooke

Todo:

TODO Move this code into an include file much like the fuel interrupts such that it can be used for multiple UART SCI devices without duplication.

Todo:

TODO Remove the debug code that uses the IO ports to light LEDs during specific actions.

Definition at line 150 of file commsISRs.c.

References BIT0, BIT1, BIT2, BIT3, BIT4, BIT5, BIT6, BIT7, CLEAR_ALL_SOURCE_ID_FLAGS, COM_CLEAR_SCI0_INTERFACE_ID, COM_SET_SCI0_INTERFACE_ID, Counter::commsChecksumMismatches, Counters, ESCAPE_BYTE, ESCAPED_ESCAPE_BYTE, ESCAPED_START_BYTE, ESCAPED_STOP_BYTE, PORTA, PORTB, receiveAndIncrement(), resetReceiveState(), RuntimeVars, RX_BUFFER_SIZE, RX_READY_TO_PROCESS, RX_SCI_ESCAPED_NEXT, RX_SCI_NOT_ESCAPED_NEXT, RXBufferContentSourceID, RXBufferCurrentPosition, RXCalculatedChecksum, RXPacketLengthReceived, RXStateFlags, SCI0CR2, SCI0DRL, SCI0SR1, SCICR2_RX_DISABLE, SCICR2_RX_ISR_DISABLE, SCICR2_RX_ISR_ENABLE, SCICR2_TX_ISR_DISABLE, SCICR2_TX_ISR_ENABLE, SCISR1_RX_FRAMING, SCISR1_RX_NOISE, SCISR1_RX_OVERRUN, SCISR1_RX_PARITY, SCISR1_RX_REGISTER_FULL, SCISR1_TX_REGISTER_EMPTY, sendAndIncrement(), Counter::serialEscapePairMismatches, Counter::serialFramingErrors, RuntimeVar::serialISRRuntime, Counter::serialNoiseErrors, Counter::serialOverrunErrors, Counter::serialPacketsOverLength, Counter::serialParityErrors, Counter::serialStartsInsideAPacket, START_BYTE, STOP_BYTE, TCNT, TXBufferCurrentPositionSCI0, TXBufferInUseFlags, TXByteEscaped, and TXPacketLengthToSendSCI0.

              {
    /* Read the flags register */
    unsigned char flags = SCI0SR1;
    /* Note: Combined with reading or writing the data register this also clears the flags. */

    /* Start counting */
    unsigned short start = TCNT;

    /* If the RX interrupt is enabled check RX related flags */
    if(SCI0CR2 & SCICR2_RX_ISR_ENABLE){
        /* Grab the received byte from the register */
        unsigned char rawByte = SCI0DRL;

        PORTB |= BIT0;

        /* Record error conditions always */
        unsigned char resetOnError = 0;
        /* If there is noise on the receive line record it */
        if(flags & SCISR1_RX_NOISE){
            Counters.serialNoiseErrors++;
            resetOnError++;
        }/* If an overrun occurs record it */
        if(flags & SCISR1_RX_OVERRUN){
            Counters.serialOverrunErrors++;
            resetOnError++;
        }/* If a framing error occurs record it */
        if(flags & SCISR1_RX_FRAMING){
            Counters.serialFramingErrors++;
            resetOnError++;
        }/* If a parity error occurs record it */
        if(flags & SCISR1_RX_PARITY){
            Counters.serialParityErrors++;
            resetOnError++;
        }

        /* Drop out because of error flags  */
        if(resetOnError){
            resetReceiveState(CLEAR_ALL_SOURCE_ID_FLAGS);
            PORTB |= BIT1;
            return;
        }

        /* If there is data waiting to be received */
        if(flags & SCISR1_RX_REGISTER_FULL){
            PORTB |= BIT2;
            /* Look for a start bresetReceiveStateyte to indicate a new packet */
            if(rawByte == START_BYTE){
                PORTB |= BIT3;
                /* If another interface is using it (Note, clear flag, not normal) */
                if(RXBufferContentSourceID & COM_CLEAR_SCI0_INTERFACE_ID){
                    /* Turn off our reception */
                    SCI0CR2 &= SCICR2_RX_DISABLE;
                    SCI0CR2 &= SCICR2_RX_ISR_DISABLE;
                    PORTB |= BIT4;
                }else{
                    PORTB |= BIT5;
                    /* If we are using it */
                    if(RXBufferContentSourceID & COM_SET_SCI0_INTERFACE_ID){
                        /* Increment the counter */
                        Counters.serialStartsInsideAPacket++;
                    }
                    /* Reset to us using it unless someone else was */
                    resetReceiveState(COM_SET_SCI0_INTERFACE_ID);
                }
            }else if(RXPacketLengthReceived >= RX_BUFFER_SIZE){
                /* Buffer was full, record and reset */
                Counters.serialPacketsOverLength++;
                resetReceiveState(CLEAR_ALL_SOURCE_ID_FLAGS);
                PORTB |= BIT6;
            }else if(RXBufferContentSourceID & COM_SET_SCI0_INTERFACE_ID){
                if(RXStateFlags & RX_SCI_ESCAPED_NEXT){
                    PORTB |= BIT7;
                    /* Clear escaped byte next flag, thanks Karsten! ((~ != !) == (! ~= ~)) == LOL */
                    RXStateFlags &= RX_SCI_NOT_ESCAPED_NEXT;

                    if(rawByte == ESCAPED_ESCAPE_BYTE){
                        /* Store and checksum escape byte */
                        receiveAndIncrement(ESCAPE_BYTE);
                    }else if(rawByte == ESCAPED_START_BYTE){
                        /* Store and checksum start byte */
                        receiveAndIncrement(START_BYTE);
                    }else if(rawByte == ESCAPED_STOP_BYTE){
                        /* Store and checksum stop byte */
                        receiveAndIncrement(STOP_BYTE);
                    }else{
                        /* Otherwise reset and record as data is bad */
                        resetReceiveState(CLEAR_ALL_SOURCE_ID_FLAGS);
                        Counters.serialEscapePairMismatches++;
                    }
                }else if(rawByte == ESCAPE_BYTE){
                    PORTA |= BIT0;
                    /* Set flag to indicate that the next byte should be un-escaped. */
                    RXStateFlags |= RX_SCI_ESCAPED_NEXT;
                }else if(rawByte == STOP_BYTE){
                    PORTA |= BIT1;
                    /* Turn off reception */
                    SCI0CR2 &= SCICR2_RX_DISABLE;
                    SCI0CR2 &= SCICR2_RX_ISR_DISABLE;

                    /* Bring the checksum back to where it should be */
                    unsigned char RXReceivedChecksum = (unsigned char)*(RXBufferCurrentPosition - 1);
                    RXCalculatedChecksum -= RXReceivedChecksum;

                    /* Check that the checksum matches */
                    if(RXCalculatedChecksum == RXReceivedChecksum){
                        /* If it's OK set process flag */
                        RXStateFlags |= RX_READY_TO_PROCESS;
                        PORTA |= BIT2;
                    }else{
                        PORTA |= BIT3;
                        /* Otherwise reset the state and record it */
                        resetReceiveState(CLEAR_ALL_SOURCE_ID_FLAGS);
                        Counters.commsChecksumMismatches++;
                    }
                }else{
                    PORTA |= BIT4;
                    /* If it isn't special process it! */
                    receiveAndIncrement(rawByte);
                }
            }else{
                /* Do nothing : drop the byte */
                PORTA |= BIT5;
            }
        }
    }

    /* If the TX interrupt is enabled check the register empty flag. */
    if((SCI0CR2 & SCICR2_TX_ISR_ENABLE) && (flags & SCISR1_TX_REGISTER_EMPTY)){
        /* Get the byte to be sent from the buffer */
        unsigned char rawValue = *TXBufferCurrentPositionSCI0;

        if(TXPacketLengthToSendSCI0 > 0){
            if(TXByteEscaped == 0){
                /* If the raw value needs to be escaped */
                if(rawValue == ESCAPE_BYTE){
                    SCI0DRL = ESCAPE_BYTE;
                    TXByteEscaped = ESCAPED_ESCAPE_BYTE;
                }else if(rawValue == START_BYTE){
                    SCI0DRL = ESCAPE_BYTE;
                    TXByteEscaped = ESCAPED_START_BYTE;
                }else if(rawValue == STOP_BYTE){
                    SCI0DRL = ESCAPE_BYTE;
                    TXByteEscaped = ESCAPED_STOP_BYTE;
                }else{ /* Otherwise just send it */
                    sendAndIncrement(rawValue);
                }
            }else{
                sendAndIncrement(TXByteEscaped);
                TXByteEscaped = 0;
            }
        }else{ /* Length is zero */
            /* Turn off transmission interrupt */
            SCI0CR2 &= SCICR2_TX_ISR_DISABLE;
            /* Send the stop byte */
            SCI0DRL = STOP_BYTE;
            while(!(SCI0SR1 & 0x80)){/* Wait for ever until able to send then move on */}
            SCI0DRL = STOP_BYTE; // nasty hack that works... means at least one and most 2 stops are sent so stuff works, but is messy... there must be a better way.
            /* Clear the TX in progress flag */
            TXBufferInUseFlags &= COM_CLEAR_SCI0_INTERFACE_ID;
        }
    }

    /* Record how long the operation took */
    RuntimeVars.serialISRRuntime = TCNT - start;
}

Here is the call graph for this function:

void SecondaryRPMISR

(

void

)

Use the rising and falling edges...................

Secondary RPM ISR

Todo:

TODO Docs here!

Todo:

TODO Add a check for 1 skip pulse of the 8x track, to prevent possible incorrect sync.

Todo:

TODO Possibly make virtual CAS 16-bit so was can get rid of floating points and use for syncing

Secondary RPM ISR

Todo:

TODO Docs here!

Secondary RPM ISR

Todo:

TODO Docs here!

Secondary RPM ISR

Similar to the primary one.

Todo:

TODO bring this documentation up to date.

Todo:

TODO finish this off to a usable standard.

Secondary RPM ISR

Unused in this decoder.

Secondary RPM ISR

Todo:

TODO Docs here!

Todo:

TODO discard narrow ones! test for tooth width and tooth period the width should be based on how the hardware is setup. IE the LM1815 is adjusted to have a pulse output of a particular width. This noise filter should be matched to that width as should the hardware filter.

Definition at line 109 of file LT1-360-8.c.

References changeSyncStatus(), CLEAR_PRIMARY_SYNC, fixedConfig1::coreSettingsA, coreStatusA, Counters, Counter::crankSyncLosses, engineCyclePeriod, fixedConfigs1, ISRLatencyVars, isSynced, lastSecondaryOddTimeStamp, lastSecondaryPulseLeadingTimeStamp, lastSecondaryPulseTrailingTimeStamp, lengthOfSecondaryLowPulses, PORTJ, PORTM, PRIMARY_POLARITY, PRIMARY_SYNC, primaryPulsesPerSecondaryPulse, PrimaryTeethDuringHigh, PrimaryTeethDuringLow, PTIT, RuntimeVars, SECONDARY_POLARITY, ISRLatencyVar::secondaryInputLatency, RuntimeVar::secondaryInputLeadingRuntime, RuntimeVar::secondaryInputTrailingRuntime, Counter::secondaryTeethSeen, TC1, TCNT, TFLG, TFLGOF, LongTime::timeLong, timerExtensionClock, LongTime::timeShorts, and VCAS.

                          {
    /* 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 */
    unsigned char risingEdge;
    if(fixedConfigs1.coreSettingsA & PRIMARY_POLARITY){
            risingEdge = PTITCurrentState & 0x01;
        }else{
            risingEdge = !(PTITCurrentState & 0x01);
        }
    PORTJ |= 0x40;  /* echo input condition */

    if (!isSynced & risingEdge){ /* If the CAS is not in sync get window counts and set virtual CAS position */
          /* if signal is high that means we can count the lows */
            switch (PrimaryTeethDuringLow){
            case 23: /* wheel is at 0 deg TDC #1, set our virtual CAS to tooth 0 of 720 */
            {
                VCAS = 0 ;
                changeSyncStatus((unsigned char) 1);
                break;
            }
            case 38: /* wheel is at 90 deg TDC #4, set our virtual CAS to tooth 180 of 720 */
            {
                VCAS = 180;
                changeSyncStatus((unsigned char) 1);
                break;
            }
            case 33: /* wheel is at 180 deg TDC #6 set our virtual CAS to tooth 360 of 720 */
            {
                VCAS = 360;
                changeSyncStatus((unsigned char) 1);
                break;
            }
            case 28: /* wheel is at 270 deg TDC #7 set our virtual CAS to tooth 540 of 720 */
            {
                VCAS = 540;
                changeSyncStatus((unsigned char) 1);
                break;
            }
            default :
            {
            Counters.crankSyncLosses++; /* use crankSyncLosses variable to store number of invalid count cases while attempting to sync*/
                break;
            }
            PrimaryTeethDuringLow = 0; /* In any case reset counter */
            }
        }
    if(!isSynced & !risingEdge){/* if the signal is low that means we can count the highs */
            switch (PrimaryTeethDuringHigh){   /* will need to additional code to off-set the initialization of PACNT since they are not
                                                 evenly divisible by 5 */
            case 7: /* wheel is at 52 deg, 7 deg ATDC #8 set our virtual CAS to tooth 104 of 720 */
            {

                break;
            }
            case 12: /* wheel is at 147 deg, 12 deg ATDC #3 set our virtual CAS to tooth 294 of 720 */
            {

                break;
            }
            case 17: /* wheel is at 242 deg, 17 deg ATDC #5 set our virtual CAS to tooth 484 of 720 */
            {

                break;
            }
            case 22: /* wheel is at 337 deg, 22 deg ATDC #2 set our virtual CAS to tooth 674 of 720 */
            {

                break;
            }
            default :
            {
                Counters.crankSyncLosses++; /* use crankSyncLosses variable to store number of invalid/default count cases while attempting to sync*/
                break;
            }

            }
            PrimaryTeethDuringHigh = 0;  /* In any case reset counter */
        }
    if(isSynced & risingEdge){  /* We are in sync and need to make sure our counts are good */

        /* System is synced so use adjusted count numbers to check sync */
    }
}

Here is the call graph for this function:

void StagedOffISR

(

void

)

Definition at line 72 of file injectionISRs.c.

References PITINTE.

                       {
    // clear the flag
    PITINTE |= 0x08;

    // bit bang off the correct injector channel
    // TODO figure out which channel and switch it
    // TODO set the flag for that channel

    // if there are other staged channels pending, schedule them and adjust the data
    // TODO

    /* Clear the PIT3 flag */
    // TODO
}

void StagedOnISR

(

void

)

Definition at line 51 of file injectionISRs.c.

References fixedConfig1::coreSettingsA, fixedConfigs1, PITINTE, and STAGED_END.

                      {
    // clear the flag
    PITINTE |= 0x04;

    // bit bang on the correct injector channel
    // TODO figure out which channel and switch it
    // TODO set the flag for that channel

    // if there are other staged channels pending, schedule them and adjust the data
    // TODO

    /* If staged injection needs the end point scheduled, do it now (otherwise it will turn off naturally with the main injector) */
    if(!(fixedConfigs1.coreSettingsA & STAGED_END)){
        // TODO schedule the end of staged injection with PIT 3
    }

    /* Clear the PIT2 flag */
    // TODO
}

void TimerOverflow

(

void

)

ECT overflow handler.

When the ECT free running timer hits 65535 and rolls over, this is run. Its job is to extend the timer to an effective 32 bits for longer measuring much longer periods with the same resolution.

Author:

Fred Cooke

Definition at line 176 of file realtimeISRs.c.

References TFLGOF, and timerExtensionClock.

                    {
    /* Increment the timer extension variable */
    timerExtensionClock++;

    /* Clear the timer overflow interrupt flag */
    TFLGOF = 0x80;
}

void UISR

(

void

)

Unimplemented Interrupt Handler.

Unimplemented interrupt service routine for calls we weren't expecting. Currently this simply counts bad calls like any other event type.

Author:

Fred Cooke

Definition at line 50 of file miscISRs.c.

References Counter::callsToUISRs, and Counters.

               {
    /* Increment the unimplemented ISR execution counter */
    Counters.callsToUISRs++;
}

void VRegAPIISR

(

void

)

void XIRQISR

(

void

)

XIRQ/PE0 pin ISR.

Interrupt handler for edge events on the XIRQ/PE0 pin. Not currently used.

Author:

Fred Cooke

Definition at line 218 of file miscISRs.c.

References Counter::callsToUISRs, and Counters.

                  {
    /* Clear the flag */
    // ?? TODO

    /* Increment the unimplemented ISR execution counter */
    Counters.callsToUISRs++;
}