// MiataBrain1 ECU V0.5
// 
// Copyright (c)2010 Matt Parsons
//
// Mazda MX5 Engine Control Unit Software for the Arduino Microcontroller Board.
// 
// Use 8bit variables where ever possible to speed processing.
// The basic unit of time for the sequence is the Microsecond (unit written as "us"), but I have used
// a 128us timer for all time critical functions. This is due to a limitation in the AVRmega328 CPU
// used in the Arduino (what do you want from a $2 chip?). This is doesn't cause any real issues 
// but be sure to remember than events might occur 128us later than requested. :)  

// defines for setting and clearing register bits
#ifndef cbi
#define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit))
#endif
#ifndef sbi
#define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit))
#endif

// We need includes for the 128us timer
#include <avr/interrupt.h>  
#include <avr/io.h>

unsigned long hRev; //number of half crank revolutions. x2 for engine life time crank revs.

// Cycle Time Variables
unsigned long MSPT;
unsigned long MSLastFallingEdge;
unsigned long MSLastRisingEdge;
byte Phase;
unsigned long segTime;

typedef struct{
byte PinCrank;
byte PinCam;
byte PinIgnA;
byte PinIgnB;
byte PinInj1;
byte PinInj2;
byte PinInj3;
byte PinInj4;
} ECUHW;

//Board pin assignment
/* Pins 1 and 2 are for the USB link, if you don't want/need that then you get two extra pins.

  Defaults here:  2=CKP input from Engine
                  3=CMP input from Engine
                  4=Ignitor1 and 4
                  5=Ignitor2 and 3
                  6=Injector Cylinder 1
                  7=Injector Cylinder 2
                  8=Injector Cylinder 3
                  9=Injector Cylinder 4

Adjust these below if your hardware needs them on different pins :)
*/

ECUHW board ={2,3,4,5,6,7,8,9};


//Iginition Variables, you can adjust the firing sequence here
byte IgNActive[]={board.PinIgnB,board.PinIgnA,board.PinIgnB,board.PinIgnA};

//Injector Variables, You can adjust the injector sequence here
byte InJActive[] = {board.PinInj4,board.PinInj2,board.PinInj1,board.PinInj3};
unsigned long InjFlowTime;

//Engine Sensor variables
int ThrottlePositionSensor;
int AirFlowSensor;
int AirTemp;
int CoolentTemp;

//Engine Control Variables
//Here we can control the various emission valves etc...
int throttleServoPosition; // in microseconds. on a regular MX5 this would be the ISC valve.

//User Variables, these will also be adjustable in real time via serial link. I think I will save these value in te EEPROM.
unsigned int User_DwellTime=2500;//2.5 milliseconds default (CANNOT BE NEGATIVE).
        long User_AdvanceRetard=0; //Advance retard accross the RPM band. ticks.
        long User_Mixture=0; // adjust the fuel mixture, rich/lean. +-ms
        long User_RevLimit=8000; //Rev limiter... not used at this time.

//Countdowns for the interrupt.
unsigned long dwellStartCountdown=-1;
unsigned long dwellEndCountdown=-1;
unsigned long InjectorCounter=0;

byte ignLive=0; //Just a little check flag to make sure we can't burn out the coils... just being a bit over cautious here.


unsigned long Inj1OnTime;  //Start time of inj1
unsigned long Inj1OffTime;
unsigned long Inj2OnTime;  //Start time of inj2
unsigned long Inj2OffTime;
unsigned long Inj3OnTime;  //Start time of inj3
unsigned long Inj3OffTime;
unsigned long Inj4OnTime;  //Start time of inj4
unsigned long Inj4OffTime;

//Timer2 overflow interrupt vector handler, called every 128us
ISR(TIMER2_OVF_vect) {
  dwellStartCountdown-=128;
  dwellEndCountdown-=128;
  
    InjectorCounter++;
  
  if(dwellStartCountdown<128){IgnitorOn();ignLive=1;}
  if(dwellEndCountdown<128){IgnitorOff();ignLive=0;}
 
 
  if(InjectorCounter==Inj1OnTime){digitalWrite(InJActive[2],HIGH);}
  if(InjectorCounter==Inj1OffTime){digitalWrite(InJActive[2],LOW);}  
  
  if(InjectorCounter==Inj2OnTime){digitalWrite(InJActive[1],HIGH);}
  if(InjectorCounter==Inj2OffTime){digitalWrite(InJActive[1],LOW);} 
  
  if(InjectorCounter==Inj3OnTime){digitalWrite(InJActive[3],HIGH);}
  if(InjectorCounter==Inj3OffTime){digitalWrite(InJActive[3],LOW);} 
  
  if(InjectorCounter==Inj4OnTime){digitalWrite(InJActive[0],HIGH);}
  if(InjectorCounter==Inj4OffTime){digitalWrite(InJActive[0],LOW);} 
  
};  

void setup(){

//Set up the 128us timer, this will run the injectors and start/end the coil dwell
  //Timer2 Settings: Timer Prescaler /128, WGM mode 0
  TCCR2A = 0;
  TCCR2B = 0<<CS22 | (1<<CS21) | (0<<CS20);
  //Timer2 Overflow Interrupt Enable  
  TIMSK2 = 1<<TOIE2;
  //reset timer
  TCNT2 = 0;
  
// set ADC prescale to 16, 21us per sample, without this the ADC will run too slowly
  sbi(ADCSRA,ADPS2) ;
  cbi(ADCSRA,ADPS1) ;
  cbi(ADCSRA,ADPS0) ;
  
  Serial.begin(115200);
  Serial.print("\n!!!!System Boot!!!!\nMiataBrain1 ECU v0.5\nCopyright (c)2010 Matt Parsons,\nAll rights reserved.\n\nMazda MX5 Engine Control Unit Software for\nthe Arduino Microcontroller Board.\nPlease see GPL for licence restrictions.\n!!!!!!!!!!!!!!!!!!!\n\nSynchronising with Engine!\n");
  
  
pinMode(board.PinCam,INPUT);  
pinMode(board.PinCrank,INPUT);  

pinMode(board.PinIgnA,OUTPUT);  
pinMode(board.PinIgnB,OUTPUT);
pinMode(board.PinInj1,OUTPUT);  
pinMode(board.PinInj2,OUTPUT);  
pinMode(board.PinInj3,OUTPUT);  
pinMode(board.PinInj4,OUTPUT);  

pinMode(13,OUTPUT); //Just the on board LED so I can see the CKP cycles, please remove if you need to use this pin

//The Engine needs to be turing over on the starter by this point.
//Time to Sync with the Engine with the Arduino...
//You might want to switch on the fuel injectors here to fill the manifold with fuel.
//

Phase=1; //default Phase state (if we leave the sync at half way through an engine cycle) 

Serial.println("Wait for the Cam");
while(digitalRead(board.PinCam)==LOW){}

Serial.println("Wait for the Crank");
while(digitalRead(board.PinCrank)==LOW){}
MSPT=micros(); //Save the current time somewhere... 

Serial.println("Wait for the Crank signal to go low");
while(digitalRead(board.PinCrank)==HIGH){}
MSLastFallingEdge=micros();
MSPT=(micros()-MSPT)/100;

Serial.println("We are now synchronised");
}

void loop(){
  //Serial.println("Falling edge of Crank signal");
    segTime=micros();
  
  //Advance the phase... and check the cam... if HIGH, then we are back to Cylinder 1 TDC
    Phase++;
    if(digitalRead(board.PinCam)==HIGH){Phase=0;hRev++;hRev=hRev>>0;}
  
  //Calculate RPM... Microseconds per 512th of a revolution in our case
    MSPT =(segTime - MSLastFallingEdge) >> 8;
    MSLastFallingEdge = segTime;
   
    //calculate dwellend time; this gets revised on the rising edge sparkTicks()
       dwellEndCountdown=(sparkTicks()+155)*MSPT;
        
    //calculate dwellstart time: (dwellend-User_DwellTime)
      dwellStartCountdown=dwellEndCountdown-User_DwellTime;
      
    //Set up the injector timers, this is a bit clumsy... but it works and is very quick, will probly move to a switch strucutre.  
    if(Phase==0){
     Inj3OffTime=InjectorCounter+((922*MSPT) >> 7);
     Inj3OnTime=(Inj3OffTime-(InjFlowTime >> 7));
   }
    if(Phase==1){
     Inj4OffTime=InjectorCounter+((922*MSPT) >> 7);
     Inj4OnTime=(Inj4OffTime-(InjFlowTime >> 7));
   }
    if(Phase==2){
     Inj2OffTime=InjectorCounter+((922*MSPT) >> 7);
     Inj2OnTime=(Inj2OffTime-(InjFlowTime >> 7));
   }
     if(Phase==3){
     Inj1OffTime=InjectorCounter+((922*MSPT) >> 7);
     Inj1OnTime=(Inj1OffTime-(InjFlowTime >> 7));
   }
      
    //calculate injector flow time, I might limit this once per engine cycle... but we need to test to see what works best.
      setInjFlowTime();
      
    //Aquire analog signals...  I might limit this once per engine cycle... but we need to test to see what works best.
      aquireAnalog();
      
    //Serial link - TODO: Need to set up ring buffer...
      dataLink();
    
  //Wait for rising edge of Crank signal
    while(digitalRead(board.PinCrank)==LOW){} 
////////////////////////////////////////////////////////////////////////
    segTime=micros();
    
    //Calculate RPM... Microseconds per 512th of a revolution in our case
    MSPT =(segTime - MSLastRisingEdge) >> 8;
    MSLastRisingEdge = segTime;
          
    //calculate dwellend time; this is a revised time based on the rising edge, 
    //if the engine has sped up or slowed down since the falling edge, this will adjust the spark.
    //accuracy here is VERY improtant!
    dwellEndCountdown=(sparkTicks())*MSPT;
      
                                              digitalWrite(13,HIGH); //just an LED signal for me please remove
 //Wait for Falling Edge of Crank signal... to start the next phase, Yay!! We made it!
  while(digitalRead(board.PinCrank)==HIGH){}   
 
  if(ignLive==1){Serial.print("MISFIRE");error();} // If this is true, then the spark has missed the deadline This IS the end of the world :(
                                              digitalWrite(13,LOW); //just an LED signal for me please remove
//////////////////////////////////////////////////////////////////////// 
}

  unsigned long sparkTicks(){
    return 92+User_AdvanceRetard; //92 is the number of ticks after the rising edge for 10Deg BTDC
  }
  
  void IgnitorOn(){
        digitalWrite(IgNActive[Phase],HIGH);
  }
    
    void IgnitorOff(){
        digitalWrite(IgNActive[Phase],LOW);
  }
  
      
  void setInjFlowTime(){
    //Here is where we work out how long the injector need to open
    //this will be based on Throttle, AirFlow, AirTemp, coolent temp etc...
    InjFlowTime=2000+User_Mixture; //2 milliseconds, as a default... run a real engine with closed throttle and adjust until you get the expected idle RPM.
  }
  
    void aquireAnalog(){
    //We read them, but don't use them yet
    ThrottlePositionSensor=analogRead(0);
    AirFlowSensor=analogRead(1);
    AirTemp=analogRead(2);
    CoolentTemp=analogRead(3);
  }
  
    void dataLink(){
    // Just a stub for now
    }
  
  void error(){ //I will need to put some proper error codes here
       Serial.print("Error!");
     //Switch Everything off
     digitalWrite(IgNActive[0],LOW);
     digitalWrite(IgNActive[1],LOW);
     digitalWrite(IgNActive[2],LOW);
     digitalWrite(IgNActive[3],LOW);
     digitalWrite(InJActive[0],LOW);
     digitalWrite(InJActive[1],LOW);
     digitalWrite(InJActive[2],LOW);
     digitalWrite(InJActive[3],LOW);
       
    while(true){} //Into a busy loop, wait for a reset.
  }

unsigned int User_DwellTime=2500;//2.5 milliseconds default (CANNOT BE NEGATIVE).
        long User_AdvanceRetard=0; //Advance retard accross the RPM band. measured in rotation ticks (setting this to 6, will perform the 14degree advance mod ;) ).
        long User_Mixture=0; // adjust the fuel mixture, rich/lean. +- us
        long User_RevLimit=8000; //Rev limiter... not used at this time.

#include <Servo.h>
#include <avr/pgmspace.h>

//Servo range closed 63-155 open
PROGMEM  prog_uint16_t fuelm[32][15]={
{100,4200,5200,5500,5500,5500,6000,6200,6500,6700,6900,7100,7300,7500,8000},
{100,4000,5000,5400,5400,5400,5800,6000,6300,6500,6700,6900,7100,7300,8000},
{100,4000,5000,5300,5300,5300,5600,5800,6100,6300,6500,6700,6900,7100,8000},
{100,4000,5000,5200,5200,5200,5600,5800,5900,6100,6300,6500,6700,6900,8000},
{100,4000,4800,5100,5100,5100,5500,5800,5900,6100,6300,6500,6700,6900,7500},
{100,4000,4800,5000,5000,5000,5500,5800,5900,6100,6300,6500,6700,6900,7500},
{100,4000,4800,4900,4900,5000,5500,5800,5900,6100,6300,6500,6700,6900,7500},
{100,3900,4600,4700,4800,5000,5500,5800,5900,6100,6300,6500,6700,6900,7500},
{100,3900,4600,4500,4700,5000,5500,5800,5800,6000,6200,6400,6600,6800,7500},
{100,3900,4600,4400,4700,4900,5400,5700,5800,5950,6100,6250,6400,6550,7500},
{100,3900,4600,4400,4700,4900,5400,5700,5800,5950,6100,6250,6400,6550,7500},
{100,3900,4600,4400,4600,4900,5400,5700,5800,5950,6100,6250,6400,6550,7500},
{100,3900,4400,4400,4600,4800,5400,5700,5500,5650,5800,5950,6100,6250,7000},
{6000,3800,4400,4400,4600,4800,5300,5500,5500,5650,5800,5950,6100,6250,7000},
{6000,3800,4400,4400,4500,4800,5300,5500,5500,5650,5800,5950,6100,6250,7000},
{6000,3800,4400,4400,4500,4800,5300,5500,5300,5450,5600,5750,5900,6050,7000},
{6000,3800,4200,4200,4500,4700,5300,5500,5300,5450,5600,5750,5900,6050,7000},
{6000,3800,4000,4200,4500,4700,5200,5400,5200,5350,5500,5650,5800,5950,7000},
{6000,3700,3900,4200,4400,4700,5150,5350,5250,5350,5450,5600,5650,5750,7000},
{6000,3700,3800,4200,4400,4700,5050,5250,5150,5250,5350,5550,5600,5700,7000},
{6000,3700,3800,4200,4400,4700,5000,5200,5100,5200,5300,5550,5550,5650,7000},
{6000,3700,3800,4000,4400,4600,4950,5150,5150,5250,5350,5650,5600,5700,7000},
{6000,3700,3700,4000,4300,4500,5000,5100,5200,5300,5400,5800,5700,5800,7000},
{6000,3600,3700,4000,4300,4500,5000,5100,5200,5300,5400,5800,5700,5800,6500},
{6000,3600,3700,4000,4300,4500,5000,5100,5100,5200,5300,5700,5600,5700,6000},
{6000,3600,3700,3900,4200,4400,4750,4850,4950,5050,5150,5450,5400,5500,5500},
{6000,3600,3500,3800,4100,4300,4500,4600,4700,4750,4800,5000,4950,5000,5000},
{6000,3600,3300,3800,4000,4200,4300,4400,4600,4650,4700,4900,4850,4900,5000},
{6000,3500,3100,3800,3900,4100,4050,4150,4450,4500,4550,4700,4700,4750,5000},
{5500,3400,2800,3400,3800,4000,3850,3950,4350,4400,4450,4600,4600,4650,5000},
{5000,3100,2600,3200,3800,3800,3650,3650,4150,4200,4250,4350,4350,4400,5001},
{4500,3000,2300,2600,2800,2300,2400,100,100,100,100,100,100,100,100}};


int rpmcount = 0;
int airopen=7400, fuel=2800;
byte temp=0,throatle=63,t1,t2,inj=0;
unsigned long time, dt,wheel,vel=0,trip=0,rpm=0;
boolean aire=0,fuele=0,spd=0;
const byte AirValvePin = 6;
const byte FuelValvePin = 7;
const byte thrin=1;
Servo thr;

void setup()
{
  Serial.begin(9600);
  thr.attach(9);
  pinMode(AirValvePin, OUTPUT);
  pinMode(FuelValvePin, OUTPUT);

  digitalWrite(FuelValvePin, LOW);
  digitalWrite(AirValvePin, LOW);
  clearLCD();
  Serial.print("Alive");
}

void loop()
{
  if (aire){    
    digitalWrite(AirValvePin, HIGH);
    delayMicroseconds(airopen);
    digitalWrite(AirValvePin, LOW);
    aire=false;
  }

  if (!aire && fuele){    
    digitalWrite(FuelValvePin, HIGH);
    delayMicroseconds(fuel-100);
    digitalWrite(FuelValvePin, LOW);
    fuele=false;
    //LCD print out    
    clearLCD();
    /*Serial.print(t1, DEC);
    Serial.print("_");
    Serial.print(t2,DEC);
    Serial.print("F:");
    Serial.print(fuel-100,DEC);
    //selectLineTwo();
    Serial.print(rpm,DEC);
    Serial.print(" SPD");*/
    Serial.println((vel/10));    
  }

  if (!aire && !fuele) {
    temp=throatle;
    throatle=constrain(map(analogRead(thrin),0,600,64,155),64,155);
    if (temp!=throatle)
      thr.write(throatle);

    //cam sensor
    if (inj>0)
      if (analogRead(0)<400)
        inj=0;

    if (inj==0) {
      if (analogRead(0)>400) 
        inj=1;
      rpmcount = rpmcount+inj;
    }


    // Speed sensor
    if (spd)
      if (analogRead(4)>250)
        spd=false;

    if (!spd)
      if (analogRead(4)<250) {
        vel=32950/(millis()-wheel);  //mph x10
        wheel=millis();
        spd=true;
        trip++;
      }
  }

  if (rpmcount!=3) 
  {
    dt=micros() - time;
    rpmcount = (rpmcount > 3)+2*(rpmcount != 0);
    time = micros();

    if ((dt>20000) && (dt<1200000) && (rpmcount==3)) {  //Operational Condition test 100 to 6000 rpm range
      aire=true;
      fuele=aire;
      rpm=120000000/dt;
      t1=constrain((157-throatle)/3,0,31);
      t2=(constrain((rpm-1100)/350,0,14))*(rpm>1101);
      fuel=pgm_read_word(&fuelm[t1][t2]); 
    }
  }

}
void contactbreaker_fun() //Each two rotation, this interrupt function is run once
{
  rpmcount = rpmcount+1;
}

void selectLineTwo(){  //puts the cursor at line 0 char 0.
  Serial.print(0xFE, BYTE);   //command flag
  Serial.print(192, BYTE);    //position
}
void clearLCD(){
  Serial.print(0xFE, BYTE);   //command flag
  Serial.print(0x01, BYTE);   //clear command.
}