// MiataBrain1 ECU V0.4
// 
// 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.

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

// Cycle Time Variables
int MSPT;
unsigned long MSLastFallingEdge;
byte Phase;
byte LastPhase;
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
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};
unsigned long IgnTime;

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

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

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

void setup(){

// 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("\nSystem Boot!\n\nMiataBrain1 ECU v0.4 by Matt Parsons \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);  

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

//Wait for the Cam
while(digitalRead(board.PinCam==LOW)){}

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

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

//We are now synchronised
}

void loop(){
  //Falling edge of Crank signal
    segTime=micros();
  
    Phase++;
    if(digitalRead(board.PinCam)==HIGH){Phase=0;}
  
  //Calculate RPM... Microseconds per 512th of a revolution in our case
    MSPT =(segTime - MSLastFallingEdge) >> 8;
    MSLastFallingEdge = segTime;

  //Calculate Injector Open Time
    //This will close the injector at 156 ticks for low RPM this will be fine, at higher RPM thi will need modification.
    InjTime = segTime + ((156*MSPT)-InjFlowTime);
    
  //Aguire analog signals
    aquireAnalog();
    
  //Calculate Fuel amount...
    setInjFlowTime();
    
  //Send Serial data
    sendData();
  
  //wait for the right time to turn on injector
    while(micros()<=InjTime){}
   openInjector();

  //Wait for rising edge of Crank signal
    while(digitalRead(board.PinCrank==LOW)){} 
////////////////////////////////////////////////////////////////////////
    segTime=micros();
    
    closeInjector();
    
  //Calculate Next Time of Ig Based on RPM.
    IgnTime=segTime+(sparkTime()*MSPT); 
    
    //There will be about 800microseconds of time
    //@8000RPM here to do something :)
    //next version will have extra injector time here if needed.
    
  while(micros()<=IgnTime){}
    
    fireIgnitor();
 
 //Wait for Falling Edge of Crank signal... to start the next phase, Yay!
  while(digitalRead(board.PinCrank==HIGH)){}   
//////////////////////////////////////////////////////////////////////// 
}

  void aquireAnalog(){
    //We read them, but don't use them yet
    ThrottlePositionSensor=analogRead(0);
    AirFlowSensor=analogRead(1);
    AirTemp=analogRead(2);
    CoolentTemp=analogRead(3);
  }
    
  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=8000; //8 milliseconds, as a default... run a real engine and adjust until you get theexpected idle RPM.
  }
  
  void sendData(){
  //Just a stub function for now...
  }
  
  void openInjector(){
    
    digitalWrite(InJActive[Phase],HIGH);
  }
  
    void closeInjector(){
    
    digitalWrite(InJActive[Phase],LOW);
  }
  
  int sparkTime(){
    return 92; //92 is the number of ticks for 10Deg BTDC
  }
  
  void fireIgnitor(){
        digitalWrite(IgNActive[Phase],HIGH);
        delayMicroseconds(20);  //Looking at some diagrams suggests the pulse time for this needs to be much longer :)
        digitalWrite(IgNActive[Phase],LOW);
  }