//************************************************************
// Auther: Luke Skaff
// EET 480 - Senior Project
// Spring 2007
// Automotive engine computer (ECU) diagnostic interface
// Compiled in WinAVR
//************************************************************


//***********************************************************
//	                    Program discription
// Sends Mode 1 command set to ECU
// Stores Mode 1 data
// Cauclates disired values from stored data
// Outputs calculated data to LCD
//***********************************************************

//***********************************************************
// For more information on project visit:
// http://www.lukeskaff.com
//***********************************************************

// Dependent librarys
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <util/delay.h>

#define F_CPU 19660800UL   // CPU crystal speed 19.6608Mhz
#define FOSC 19660800UL    // CPU crystal speed 19.6608Mhz
#define BAUD 8192UL        // 8192 Baud rate



// ------ PORT & PIN Definitions -------
#define   LCD_PORT    PORTC    //8-BIT LCD data lines
#define   RS_PORT     PORTD    //Port RS line in on
#define   RS          7        //Pin # of RS line
#define   E_PORT      PORTD    //Port Enable line in on
#define   E           6        //Pin # of Enable line

#define   RXcontrol   5        //Pin # RX enable transistor

#define   DataM      0xFF 


#define Bit_Set(port,bit_num) (port = port | (0x01 << bit_num))
#define Bit_Clear(port,bit_num) (port = port & ~(0x01 << bit_num))

#define DataStreamSize  63    //Size of receiving data stream
#define CarDataSize     22    //Size of ASCII car data


unsigned char DataStream[DataStreamSize];
#define  Def_Offset     3
#define  DEF_ERROR1     3 + Def_Offset
#define  DEF_ERROR2     4 + Def_Offset
#define  DEF_ERROR3     5 + Def_Offset
#define  DEF_ERROR4     6 + Def_Offset
#define  DEF_ERROR5     7 + Def_Offset
#define  DEF_CTS        8 + Def_Offset
#define  DEF_RPM        11 + Def_Offset
#define  DEF_MPH        14 + Def_Offset
#define  DEF_BLM        20 + Def_Offset
#define  DEF_BLM_CELL   21 + Def_Offset
#define  DEF_STPS       24 + Def_Offset   // Scaled Throttle Position Sensor
#define  DEF_MAP        26 + Def_Offset   // volts = N x (5 / 255)
                                          // KPa = N * .369 + 10.354
#define  DEF_BATT       34 + Def_Offset   // volts = N / 10


unsigned char CarData_ASCII[CarDataSize];
#define  DATA_CTS_2     0  //COOLANT TEMPERATURE celcius 
#define  DATA_CTS_1     1
#define  DATA_TPS_v     2  //TPS volts

#define  DATA_RPM_4     3
#define  DATA_RPM_3     4
#define  DATA_RPM_2     5
#define  DATA_RPM_1     6

#define  DATA_MPH_3     7
#define  DATA_MPH_2     8
#define  DATA_MPH_1     9

#define  DATA_BLM_3     10
#define  DATA_BLM_2     20
#define  DATA_BLM_1     21

#define  DATA_BLM_CELL  11

#define  DATA_TPS_3     12
#define  DATA_TPS_2     13
#define  DATA_TPS_1     14

#define  DATA_MAP_3     15
#define  DATA_MAP_2     16
#define  DATA_MAP_1     17

#define  DATA_BATT_2    18
#define  DATA_BATT_1    19





//ECU trouble codes lookup table
const unsigned char PROGMEM ErrorCode_Table[]=
{
   23,22,21,16,15,14,13,12,
   35,34,33,32,31,26,25,24,
   51,46,45,44,43,42,41,36,
   63,62,61,56,55,54,53,52,
   00,00,00,00,00,66,65,64
};


//Function prototypes
void LCD_Initialize(void);
void LCD_D_Write(unsigned char);
void LCD_I_Write(unsigned char);
void LCD_Delay(void);
void USART_init(void);
void Binary_Out(unsigned char);
void Get_Car_Data(void);
//void HEX_to_ASCII(unsigned int, unsigned char &, unsigned char &, unsigned char &, unsigned char &);


// ------------------------------------------------------------------------------
// ------------------------------------------------------------------------------
// ------------------------ Program Code Starts Here ----------------------------
// ------------------------------------------------------------------------------
// ------------------------------------------------------------------------------



//******************************************************************
//* Function: LCD_Initialize                                       *
//* Initialize LCD                                                 *
//******************************************************************
void LCD_Initialize(void)
{
   Bit_Clear(E_PORT,E); // Bring enable pin low

   LCD_I_Write(0x38);   // 8-Bit data transfer mode
   LCD_I_Write(0x0C);   // Turn display on, No cursor, No blinking
   LCD_I_Write(0x01);   // Display clear, Restore to upper left position
   LCD_I_Write(0x06);   // Address counter increment after each display
   LCD_I_Write(0x02);   // Set address counter to zero, move cursor to home
}



//******************************************************************
//* Function: LCD_Write                                            *
//* Output data passed in, in data var. to LCD                     *
//* - Commented out, not used anymore -                            *
//******************************************************************
/*void LCD_Write(unsigned char data, unsigned char select)
{
   Bit_Set(E_PORT,E);

   if(select==0xFF)
      Bit_Set(RS_PORT,RS);   //LCD Data mode
   else
      Bit_Clear(RS_PORT,RS); //LCD Instruction mode

   LCD_PORT=data;

   _delay_ms(1);
   Bit_Clear(E_PORT,E);
   _delay_ms(1);

}
*/

//******************************************************************
//* Function: LCD_D_Write                                          *
//* Output data passed in, in data var. to LCD                     *
//******************************************************************
void LCD_D_Write(unsigned char data)
{
   Bit_Set(E_PORT,E);
   Bit_Set(RS_PORT,RS);   //LCD Data mode
 

   LCD_PORT=data;

   LCD_Delay();
   Bit_Clear(E_PORT,E);
   LCD_Delay();

}

//******************************************************************
//* Function: LCD_I_Write                                          *
//* Output data passed in, in data var. to LCD                     *
//******************************************************************
void LCD_I_Write(unsigned char data)
{
   Bit_Set(E_PORT,E);
   Bit_Clear(RS_PORT,RS); //LCD Instruction mode

   LCD_PORT=data;

   LCD_Delay();
   Bit_Clear(E_PORT,E);
   LCD_Delay();

}


//******************************************************************
//* Function: LCD_Delay                                            *
//* Relay function used for LCD communication                      *
//******************************************************************
void LCD_Delay(void)
{
   _delay_ms(1);
}


//******************************************************************
//* Function: USART_init                                           *
//* Enable and Initialize UART                                     *
//******************************************************************
void USART_init(void)
{
    // Set the USART baudrate registers for 8192, UBRR=149
    UBRR0H = 0;
    UBRR0L = 149; // Set for 4800 for PC testing
                  //255 = 4800 baud
                  //149 = 8192 buad
				  //127 = 9600 baud


	//UCSRnA - USART Control and Status Register A
    // Enable 2x speed change, 0=16 divider 1=8 divider
    /*
	  Bit 7 MSB
	R RXCn  -> USART Receive Complete
	0 TXCn  -> TXCn: USART Transmit Complete
	R UDREn -> USART Data Register Empty
	R FEn   -> Frame Error
	R DORn  -> Data OverRun
	R UPEn  -> USART Parity Error
	0 U2Xn  -> Double the USART Transmission Speed, 0=16 divider 1=8 divider
	0 MPCMn -> Multi-processor Communication Mode
	  Bit 0 LSB
	*/
	UCSR0A = (0<<U2X0);


    // UCSRnB - USART Control and Status Register n B
    // Enable receiver
    /*
	 Bit 7 MSB
	RXCIE0 = 0 Receive Interrupt disabled
	TXCIE0 = 0 Transmit Interrupt disabled
	UDRIE0 = 0 Interupt disabled
	RXEN0  = 1 Receive enabled
	TXEN0  = 1 Transmit enabled
	UCSZ02 = 0 8-bit mode
	RXB80  = 0 9'th RX data bit when using 9-bit UART
	TXB80  = 0 9'th TX data bit when using 9-bit UART
	 Bit 0 LSB
	*/
	UCSR0B =(1<<RXEN0)|(1<<TXEN0);

    
	// UCSRnC - USART Control and Status Register n C
	// Set the USART to asynchronous at 8 bits no parity and 1 stop bits
    /*
	  Bit 7 MSB
	0 UMSEL01 |
	0 UMSEL00 |-> Async
	0 UPM01  |
	0 UPM00  |-> No parity
	0 USBS0 -> 1 stop bits;
	1 UCSZ01  |
	1 UCSZ00  |-> 8-bit
	0 UCPOL0 -> Reciving data sampled on fallign edge
	  Bit 0 LSB
	*/
	UCSR0C =(0<<UMSEL01)|(0<<UMSEL00)|(0<<UPM01)|(0<<UPM00)|(0<<USBS0)|(1<<UCSZ01)|(1<<UCSZ00)|(0<<UCPOL0);
         
}


//******************************************************************
//* Function: Binary_Out                                           *
//* Outputs any passed in variable to LCD in binary                *
//* - Used for debugging -                                         *
//* - Commented out, not used in final working code -              *
//******************************************************************
/*
void Out_Binary(unsigned char data)
{
	for(unsigned char bitn = 8 ; bitn > 0 ; bitn--)
	{
		if( data & ( 1 << (bitn-1) ) )
			LCD_Write(0x31,0xFF); // Output 1 to LCD
		else
			LCD_Write(0x30,0xFF); // Output 0 to LCD
	}
}
*/


//*******************************************************************
//* Function: USART_Receive                                         *
//* Waits for incoming data on USART then returns it to the calling *
//* function                                                        *
//* - Commented out, not used in final working code -               *
//*******************************************************************
/*
unsigned char USART_Receive(void)
{
	// Wait for data to be received 
	while ( !(UCSR0A & (1<<RXC0)) );

	// Get and return received data from buffer
	return UDR0;
}
*/


//******************************************************************
//* Function: USART_Transmit                                       *
//* Transmit data                                                  *
//* datastream array until array is full                           *
//******************************************************************
void USART_Transmit(unsigned char data)
{
	// Wait for empty transmit buffer
	while ( !( UCSR0A & (1<<UDRE0)) );

	// Put data into buffer, sends the data
	UDR0 = data;

	// Wait for empty transmit buffer
	while ( !( UCSR0A & (1<<UDRE0)) );
}


//******************************************************************
//* Function: Get_Car_Data                                         *
//* Waits for incoming data on USART then puts received char into  *
//* datastream array until array is full                           *
//******************************************************************
void Get_Car_Data(void)
{
   unsigned int timeout;

   Bit_Set(PORTD,RXcontrol);  //Lockout recieve pin

   //Mode 1 command set
   USART_Transmit(0xF4);
	USART_Transmit(0x56);
	USART_Transmit(0x01);
	USART_Transmit(0xB5);

   Bit_Clear(PORTD,RXcontrol);  //Open up recieve pin

	for(unsigned char i = 0 ; i < DataStreamSize ; i++)
	{
      timeout=0;  // Reset timeout to zero

		// Wait for data to be received if data not recived in timout period
      // then exit loop
		while( !(UCSR0A & (1<<RXC0) )  && (timeout < 12000) )
      {
         timeout++;
      }
       
		// Get and return received data from buffer
      if(timeout == 12000)
         DataStream[i]=0;     // If timeout load 0 into datastream value
      else
		   DataStream[i]=UDR0;  // Otherwise load recieved value
	}

   Bit_Set(PORTD,RXcontrol);  //Lockout recieve pin
}


//******************************************************************
//* Function: Flash_LEDs                                           *
//* - Used for debugging -                                         *
//* - Commented out, not used in final working code -              *
//******************************************************************
/*
void Flash_LEDs()
{
   for(int i=0 ; i<20 ; i++ )
   {   
      PORTA=0x00;
      _delay_ms(1000);
      PORTA=0xFF;
      _delay_ms(1000);
   }
}
*/

//******************************************************************
//* Function: HEX_to_ASCII                                         *
//* Convert inputed 8-bit HEX data to 4 ANSII digits for LCD       *
//******************************************************************
void HEXtoASCII(unsigned int Hex_Input,unsigned char *digit4, unsigned char *digit3, unsigned char *digit2, unsigned char *digit1)
{   

   // Clear varaibles
    *digit4 = 0x00;
    *digit3 = 0x00;
    *digit2 = 0x00;
    *digit1 = 0x00;

    while(Hex_Input >= 1000)
    {
        Hex_Input=Hex_Input - 1000;
        *digit4 = *digit4 + 0x01; 
    }

    while(Hex_Input >= 100)
    {
        Hex_Input=Hex_Input - 100;
        *digit3 = *digit3 + 0x01; 
    }
    
    while(Hex_Input >= 10)
    {
        Hex_Input=Hex_Input - 10;
        *digit2 = *digit2 + 0x01;
    }
    
    *digit1 = Hex_Input; //remainder 
    
    // Convert to ASCII, OR with 0x30 produces ASCII
    *digit4 = *digit4 | 0x30;
    *digit3 = *digit3 | 0x30;
    *digit2 = *digit2 | 0x30;
    *digit1 = *digit1 | 0x30;
}



//******************************************************************
//* Function: Calculate_CarData                                    *
//* Convert raw data from data stream to real numbers and put in   *
//* ASCII format                                                   *
//******************************************************************
void Calculate_CarData()
{
   unsigned char ignore;
   unsigned int temp;

   // Calculate coolant tempature
   temp = DataStream[DEF_CTS] * 0.75 - 40;
   HEXtoASCII(temp,&ignore, &ignore, &CarData_ASCII[DATA_CTS_2], &CarData_ASCII[DATA_CTS_1]);

   // Calculate RPM
   temp = DataStream[DEF_RPM]*25;
   HEXtoASCII(temp,&CarData_ASCII[DATA_RPM_4], &CarData_ASCII[DATA_RPM_3], &CarData_ASCII[DATA_RPM_2], &CarData_ASCII[DATA_RPM_1]);

   // Calculate MPH
   temp = DataStream[DEF_MPH] / 1;
   HEXtoASCII(temp,&ignore, &CarData_ASCII[DATA_MPH_3], &CarData_ASCII[DATA_MPH_2], &CarData_ASCII[DATA_MPH_1]);

   // Calculate Block Learn Multiplier (BLM)
   temp = DataStream[DEF_BLM];
   HEXtoASCII(temp,&ignore, &CarData_ASCII[DATA_BLM_3], &CarData_ASCII[DATA_BLM_2], &CarData_ASCII[DATA_BLM_1]);

   // Calculate Throttle Position Sensor (TPS) percent
   temp = DataStream[DEF_STPS] / 2.56;
   HEXtoASCII(temp,&ignore, &CarData_ASCII[DATA_TPS_3], &CarData_ASCII[DATA_TPS_2], &CarData_ASCII[DATA_TPS_1]);

   // Calculate Manifold Air Pressure (MAP)
   temp = (DataStream[DEF_MAP] * 0.369) + 10.354;
   HEXtoASCII(temp,&ignore, &CarData_ASCII[DATA_MAP_3], &CarData_ASCII[DATA_MAP_2], &CarData_ASCII[DATA_MAP_1]);

   // Calculate Battery voltage
   temp = DataStream[DEF_BATT] / 10;
   HEXtoASCII(temp,&ignore, &ignore, &CarData_ASCII[DATA_BATT_2], &CarData_ASCII[DATA_BATT_1]);


}


//******************************************************************
//* Function: Output_CarData()                                     *
//* Output calcualted car data and trouble codes to LCD            *
//******************************************************************
void Output_CarData()
{
   unsigned char ignore;
   unsigned int  ErrorCode;
   unsigned char bitn=0;
   unsigned char code_2, code_1;
   unsigned char error_bit, error_byte;

   LCD_I_Write(0x02);   // Set address counter to zero, move cursor to home

   LCD_D_Write('R');
   LCD_D_Write('P');
   LCD_D_Write('M');
   LCD_D_Write(' ');
   LCD_D_Write(CarData_ASCII[DATA_RPM_4]);
   LCD_D_Write(CarData_ASCII[DATA_RPM_3]);
   LCD_D_Write(CarData_ASCII[DATA_RPM_2]);
   LCD_D_Write(CarData_ASCII[DATA_RPM_1]);

   LCD_D_Write(' '); //Space
   LCD_D_Write(' '); //Space
   LCD_D_Write(' '); //Space

   LCD_D_Write('M');
   LCD_D_Write('P');
   LCD_D_Write('H');
   LCD_D_Write(' ');
   LCD_D_Write(CarData_ASCII[DATA_MPH_3]);
   LCD_D_Write(CarData_ASCII[DATA_MPH_2]);
   LCD_D_Write(CarData_ASCII[DATA_MPH_1]);

   LCD_D_Write(' '); //Space
   LCD_D_Write(' '); //Space


   LCD_D_Write('B');
   LCD_D_Write('L');
   LCD_D_Write('M');
   LCD_D_Write(' ');
   LCD_D_Write(CarData_ASCII[DATA_BLM_3]);
   LCD_D_Write(CarData_ASCII[DATA_BLM_2]);
   LCD_D_Write(CarData_ASCII[DATA_BLM_1]);

   LCD_D_Write(' '); //Space
   LCD_D_Write(' '); //Space
   LCD_D_Write(' '); //Space
   LCD_D_Write(' '); //Space

   LCD_D_Write('C');
   LCD_D_Write('T');
   LCD_D_Write('S');
   LCD_D_Write(' ');
   LCD_D_Write(CarData_ASCII[DATA_CTS_2]);
   LCD_D_Write(CarData_ASCII[DATA_CTS_1]);
   LCD_D_Write('C');
   LCD_D_Write(' ');


   LCD_D_Write(' '); //Space

   LCD_D_Write('M');
   LCD_D_Write('A');
   LCD_D_Write('P');
   LCD_D_Write(' ');

   LCD_D_Write(CarData_ASCII[DATA_MAP_3]);
   LCD_D_Write(CarData_ASCII[DATA_MAP_2]);
   LCD_D_Write(CarData_ASCII[DATA_MAP_1]);
   LCD_D_Write(' '); //Space
   LCD_D_Write(' '); //Space
   LCD_D_Write(' '); //Space
   LCD_D_Write(' '); //Space

   LCD_D_Write('T');
   LCD_D_Write('P');
   LCD_D_Write('S');
   LCD_D_Write(' ');
   LCD_D_Write(CarData_ASCII[DATA_TPS_3]);
   LCD_D_Write(CarData_ASCII[DATA_TPS_2]);
   LCD_D_Write(CarData_ASCII[DATA_TPS_1]);
   LCD_D_Write('%');

   LCD_D_Write(' '); //Space

   LCD_D_Write('B');
   LCD_D_Write('A');
   LCD_D_Write('T');
   LCD_D_Write('T');
   LCD_D_Write(' ');

   
   LCD_D_Write(CarData_ASCII[DATA_BATT_2]);
   LCD_D_Write(CarData_ASCII[DATA_BATT_1]);
   LCD_D_Write('V');
   LCD_D_Write(' ');

   LCD_D_Write(' ');
   LCD_D_Write(' ');
   
   error_bit=0;  //Reset error bit to zero


   //*************************
   // Check for Trouble Codes
   //*************************
	for(error_byte = DEF_ERROR1 ; error_byte < DEF_ERROR5 ; error_byte++)
	{
   	for(bitn = 0 ; bitn < 7 ; bitn++)
   	{
         //If error bit in datastream is 1 then ouput trouble code
   		if(DataStream[error_byte] & ( 1 << (bitn) ) )
         {
            ErrorCode = (unsigned char)pgm_read_byte(&ErrorCode_Table[error_bit]);
    
            if(ErrorCode != 0) //If error code is 0 ignore trouble code
            {
               ErrorCode = (unsigned char)pgm_read_byte(&ErrorCode_Table[error_bit]);
               
               HEXtoASCII(ErrorCode,&ignore, &ignore, &code_2, &code_1);
      			LCD_D_Write(code_2);
               LCD_D_Write(code_1);
               LCD_D_Write(' ');
            }
         }

         error_bit = error_bit + 1; //Increment error bit number

   	}
    }

}


//******************************************************************
//* Function: main                                                 *
//* Main control function                                          *
//******************************************************************
int main (void)
{
   DDRA = 0xFF;                                 // Configure PORTA as output
   DDRC = 0xFF;                                 // Configure PORTC as output
   DDRD = (1<<PD1)|(1<<PD5)|(1<<PD6)|(1<<PD7);  // Configure PORTD 

   USART_init();        //Initialize USART
   LCD_Initialize();    //Initialize LCD


   // Loop forever
   while(1)
   {
      Get_Car_Data();
      Calculate_CarData();
      Output_CarData();
   }
  
  while(1)
  ;

}// End of main