Diff: OBD.cpp

Revision:

2:c4fb968de7d3

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/OBD.cpp	Sat Sep 02 11:09:35 2017 +0000
@@ -0,0 +1,749 @@
+
+
+
+/*
+______________________________________________________________________________________________________________________
+
+//                                  <<<<<<<<< OBD LIBRARIES >>>>>>>>>
+
+CHIP : STN1110 / ELM327
+-----
+
+NOTE :
+-----
+THESE CODE BLOCKS ARE TESTED IN REAL TIME BY COMMUNICATING DIRECTLY WITH CAR OBD PORT
+THERE ARE SOME UNTESTED PORTIONS IN THE CAR
+>>> VIN NUMBER
+>>> DTC
+VIN NUMBER PID NOT SUPPORTED IN THE CAR TESTED
+THE CAR DOESN'T HAVE ANY DTC AND THIS IS ALSO LEFT UNTESTED
+
+>>> THIS PARTICULAR SOURCE CODE IS COMPILED AND FOUND WITH ZERO ERRORS 
+>>> DATE : 29-MAR-2017
+>>> TIME : 1.00 PM
+
+>>> THIS PARTICULAR SOURCE CODE HAS BEEN TESTED SUCCESSFULLY
+>>> DATE : 10-APR-2017
+>>> TIME : 7:00 PM
+
+___________________
+
+Author : >> BALA <<
+___________________
+
+______________________________________________________________________________________________________________________
+
+*/
+
+#include "mbed.h"
+#include "OBD.h"
+#include "ACCELEROMETER.h"
+//#include "main.h"
+//#include "Common_Defs.h"
+//#include "Lora.h"
+
+
+RawSerial OBD_UART(PA_0, PA_1);
+Serial DEBUG_UART(USBTX, USBRX);
+
+char pass                       =   0;
+char reception_complete         =   0;
+AnalogIn   ain(PA_7);
+
+/*
+__________________________________________________________________________________________________
+
+     THE FOLLWOING ARE THE OBD COMMAND SET FOR THE STN1110 / ELM327 OBD - UART INTERPRETER
+__________________________________________________________________________________________________
+
+*/
+
+
+char obd_reset_cmd[]            =   {"ATZ\r"};
+char battery_voltage_cmd[]      =   "ATRV\r";
+char protocol_auto_detect_cmd[] =   "ATSP0\r";
+char read_CAN_protocol_cmd[]    =   "ATDPN\r";
+char allow_long_cmd[]           =   "ATAL\r";
+char engine_rpm_cmd[]           =   "010C\r";
+char vehicle_speed_cmd[]        =   "010D\r";
+char vin_number_cmd[]           =   "0902 5\r";
+char check_dtc_cmd[]            =   "03\r";
+char check_mil_cmd[]            =   "0101\r";
+
+
+/*
+__________________________________________________________________________________________________
+
+     THE FOLLOWING ARE GLOBAL VARIABLES WHICH CAN BE ACCESSED FOR FURTHER DATA PROCESSING
+__________________________________________________________________________________________________
+
+*/
+
+float   car_battery_voltage;
+long    rpm;
+float   speed1,speed2;
+long    vehicle_speed;
+char    vin_number[17];
+char    mil;
+char    no_of_stored_dtc;
+
+//_________________________________________________________________________________________________
+
+// THE FOLLWOING VARIABLES ARE GLOBAL BUT ARE USED ONLY FOR IN-LIBRARY PROCESSING
+
+char OBD_UART_RX_Buffer[100];
+char OBD_RxBuffer_End_Pos;
+char OBD_UART_RX_Size = 50;
+
+//_________________________________________________________________________________________________
+
+
+
+//*********************************************************************************************************************************************************************************
+
+// FUNCTION CALLED BY PARENT FUNCTION
+// THE FOLLOWING CODE BLOCK IS USED TO VERIFY THE RECEIVED DATA
+
+void received_data_verification(char *rcv_data_pointer, char *ref_data_pointer, char num)
+{
+    char dummy_data[num], count;
+    for(count = 0; count < num; count++)
+    {
+        //OBD_UART.putc(*rcv_data_pointer);
+        if(*rcv_data_pointer++ == *ref_data_pointer++)
+            pass = 1;
+        else   
+        {
+            pass = 0;
+            return;
+        }
+    } 
+}
+
+//*********************************************************************************************************************************************************************************
+
+void rpm_padding_for_comm_test()
+{
+
+    char count;
+    char virtual_engine_rpm[] = "010C\r41 0C 0E A2 \r\r>";
+    char engine_rpm[4];     // Vehicle speed data is returned by a 4 byte value
+    char *rpm_data_pointer;
+    char internal_count = 0;
+    char padded_rpm_17_bytes[17];
+    OBD_UART.printf("RPM Data\r\n");
+    
+    for(count = 0; count < strlen(engine_rpm_cmd); count ++)
+        OBD_UART.putc(engine_rpm_cmd[count]);
+    wait(1);
+    while(!(OBD_UART_RX_Buffer[OBD_RxBuffer_End_Pos-1] == '>'));        // Waits here until the reception complete flag has been enabled
+    
+    received_data_verification(OBD_UART_RX_Buffer, engine_rpm_cmd, (strlen(engine_rpm_cmd)-1));
+    for(count = 0; count < 5; count++)
+        OBD_UART.printf("0x%2x ",OBD_UART_RX_Buffer[count]);
+        process_engine_rpm(OBD_UART_RX_Buffer);
+    DEBUG_UART.printf("RPM Received\r\n");
+    rpm_data_pointer = virtual_engine_rpm;
+    rpm_data_pointer += 11;
+    
+    for(count = 0; count < 5; count++)
+    {
+        if(*rpm_data_pointer == ' ') {        // Negate the spaces added in between
+            rpm_data_pointer++;
+            continue; }
+        else {
+            engine_rpm[internal_count] = *rpm_data_pointer++;
+            internal_count++; }
+    }
+    
+    //OBD_UART.printf("\r\n%s", engine_rpm);
+    //OBD_UART.printf("\r\nRPMMMMMM = ");
+    for(count = 0; count < strlen(engine_rpm); count++)
+        OBD_UART.putc(engine_rpm[count]);
+    
+    for(count = 0; count < 4; count++){
+        DEBUG_UART.printf("\r\nPadded = ");
+        for(internal_count = 0; internal_count < strlen(padded_rpm_17_bytes); internal_count++)
+            OBD_UART.putc(padded_rpm_17_bytes[internal_count]);
+        //OBD_UART.printf("\r\nPadded RPM = %s", padded_rpm_17_bytes);
+        strcat(padded_rpm_17_bytes, engine_rpm); 
+    }
+        
+    strcat(padded_rpm_17_bytes, "0");
+    DEBUG_UART.printf("\r\n\r\n PADDED RPM = %s",padded_rpm_17_bytes);
+    DEBUG_UART.putc('\r');
+    for(count = 0; count < strlen(padded_rpm_17_bytes); count++){
+        DEBUG_UART.putc(padded_rpm_17_bytes[count]);
+        //Misc_Packet_Data.VIN[count] = padded_rpm_17_bytes[count];
+    }
+}
+//*********************************************************************************************************************************************************************************
+// FUNCTION CALLED FROM PARENT FUNCTION
+// THE FOLLOWING CODE BLOCK IS USED TO PROCESS THE DTC DATA FETCHED FROM THE OBD PORT OF THE CAR
+
+   
+/*
+|______________________________________________________________________________________________|
+
+FORMULA:
+-------
+t = total bytes of returned data
+n = no of dtc
+
+t = 2n + (n -1) , where (n-1) indicates the added spaces between two bytes
+t = 3n -1
+
+Therefore, n = (t + 1) / 3
+
+|______________________________________________________________________________________________|
+
+*/ 
+
+void process_dtc_data(char *dtc_data_pointer)   // Incomplete Code block
+{     
+    // char virtual_dtc_buffer[] = "03\r43 00 85\r\r>";
+    char count;
+    char internal_count;
+    char dtc_data[(4*(no_of_stored_dtc))];
+    char dtc_codes[(6*(no_of_stored_dtc))];            // Refer below 
+    
+    /*
+    _____________________________________________
+    
+    NOTE :
+    -----
+    DTC CODE ARRAY SPACE ALLOCATION
+    
+    ONE DTC CONTAINS 5 CHARACTERS
+    '\r' IS USED AS SEPARATOR (END BYTE)
+    TOTALLY TO STORE ONE DTC 6 BYTES ARE USED
+    _____________________________________________
+    
+    */
+    
+    dtc_data_pointer += 6;
+
+    // THE FOLLOWING LINES OF CODE COPIES THE DTC DATA IN A VARIABLE AND ELIMINATES THE SPACE CHARACTER
+    
+    for(count = 0; count < ((5*no_of_stored_dtc) + (no_of_stored_dtc - 1)); count++)
+    { 
+        if((*dtc_data_pointer) == '\r')
+            break;
+            
+        if((*dtc_data_pointer) == ' ')
+        {
+            dtc_data_pointer++;
+            continue;
+        }
+        
+        else
+        {
+            if((*dtc_data_pointer - 0x30) <= 9)
+                dtc_data[internal_count] = (*dtc_data_pointer) - 0x30;
+            else
+            {
+                dtc_data[internal_count] = (*dtc_data_pointer) - 0x37;
+            }
+            internal_count++;              
+            dtc_data_pointer++;
+        }
+    }   
+       
+    internal_count = 0;
+
+    char dtc_data_merged[((4*(no_of_stored_dtc)) / 2)];
+      
+    for(count = 0; count < ((4*no_of_stored_dtc)); count += 2)
+    {
+        dtc_data_merged[internal_count] = ((dtc_data[count] << 4) | dtc_data[count + 1]);
+        internal_count++;
+    }
+    
+    internal_count = 0;
+        
+    for(count = 0; count < (2*(no_of_stored_dtc)); count += 2)
+    {
+        switch(dtc_data_merged[count] & 0b11000000)
+        {
+            case 0:
+                dtc_codes[internal_count] = 'P';
+                break;
+            case 1:
+                dtc_codes[internal_count] = 'C';
+                break;
+            case 2:
+                dtc_codes[internal_count] = 'B';
+                break;
+            case 3:
+                dtc_codes[internal_count] = 'U';
+                break;
+        }
+        
+        internal_count++;
+            
+        dtc_codes[internal_count] = ((dtc_data_merged[count] & 0b00110000) + 0x30); 
+        internal_count++;
+        dtc_codes[internal_count] = ((dtc_data_merged[count] & 0b00001111) + 0x30);
+        internal_count++;
+        dtc_codes[internal_count] = (((dtc_data_merged[count + 1] & 0b11110000) >> 4) + 0x30);
+        internal_count++;
+        dtc_codes[internal_count] = ((dtc_data_merged[count + 1] & 0b00001111) + 0x30);
+        internal_count++;
+        dtc_codes[internal_count] = '\r';
+            
+        DEBUG_UART.printf("\r\nDTC CODES :");
+        DEBUG_UART.printf("\r\n%s", dtc_codes);
+    }
+}
+
+//*********************************************************************************************************************************************************************************
+
+// FUNCTION CALLED FROM PARENT FUNCTION
+// THE FOLLOWING CODE BLOCK IS USED TO PROCESS MIL DATA FETCHED FROM THE OBD PORT OF THE CAR
+
+void process_mil_data(char *mil_data_pointer)
+{
+    DEBUG_UART.printf("\r\n\r\nENTERED PROCESS MIL DATA FUNCTION");
+    char mil_data[2], mil_data_converted;
+    char count;
+    
+    // char virtual_mil_buffer = "0101\r41 01 00 04 60 00 \r\r";
+    mil_data_pointer += 11;
+    
+    for(count = 0; count < 2; count++)
+    {
+        mil_data[count] = *mil_data_pointer++;
+    }
+    
+    // THE FOLLOWING LINES OF CODE CONVERTS THE ASCII DATA TO THE HEX DATA  
+    
+    if((((mil_data[0] - 0x30) & 0x7F) <= 9) && (((mil_data[1] - 0x30) & 0x7F) <= 9))
+        mil_data_converted = (((mil_data[0] - 0x30)<<4) + (mil_data[1] - 0x30)); // Converting the ASCII data to the Hex data
+    
+    else if((((mil_data[0] - 0x30) & 0x7F) <= 9))
+        mil_data_converted = (((mil_data[0] - 0x30)<<4) + (mil_data[1] - 0x37)); // Converting the ASCII data to the Hex data
+    
+    else if((((mil_data[1] - 0x30) & 0x7F) <= 9))
+        mil_data_converted = (((mil_data[0] - 0x37)<<4) + (mil_data[1] - 0x30)); // Converting the ASCII data to the Hex data
+        
+    else
+            mil_data_converted = (((mil_data[0] - 0x37)<<4) + (mil_data[1] - 0x37)); // Converting the ASCII data to the Hex data
+    
+    // The following code lines checks for the number of Mal function indicator lamp enabled by tghe CAN ECU
+    
+    if(mil_data_converted & 0x80) // Checks for the MSB bit enabled or not which inc=dicates that the MIL is On or NOT
+    {
+        mil = 1;                // Setting the MIL flag
+        DEBUG_UART.printf("\r\nMIL (MALFUNCTION INDICATOR LAMP) IS ON");
+        no_of_stored_dtc = (mil_data_converted & 0b01111111);
+        DEBUG_UART.printf("\r\n NO OF STORED DYNAMIC TROUBLE CODE = %d", no_of_stored_dtc);
+    }
+    else {
+        mil = 0;                // Clearing the MIL flag
+        DEBUG_UART.printf("\r\nMIL (MALFUNCTION INDICATOR LAMP) IS OFF"); }
+}
+
+//*********************************************************************************************************************************************************************************
+
+// FUNCTION CALLED FROM PARENT FUNCTION
+// THE FOLLWOING CODE BLOCK IS USED TO PROCESS THE VEHICLE SPEED DATA FETCHED FROM THE OBD PORT OF THE CAR
+
+float process_vehicle_speed(char *vehicle_speed_pointer)
+{
+    char vehicle_speed_data[2];     // Vehicle speed data is returned by a 2 byte value
+    char *strtol_pointer;
+    char count;
+    //"010D\r41 0D 4F\r\r>"
+    vehicle_speed_pointer += 11;
+    //for(count = 0; count < 2; count++)
+    {
+        //vehicle_speed_data[count] = *vehicle_speed_pointer++;
+       // vehicle_speed_data[count] = 5;
+    }
+    
+    vehicle_speed =  strtol(vehicle_speed_data, &strtol_pointer, 16);
+    //speed1=0;
+    speed1=ain.read()*100.0f;///*************************adc value for tesing need to load actual speed********************************************
+    
+    DEBUG_UART.printf("\r\nVEHICLE SPEED = %ld", vehicle_speed);
+    return(speed1);
+}
+
+//*********************************************************************************************************************************************************************************
+
+// FUNCTION CALLED BY PARENT FUCTION
+// THE FOLLWOING CODE BLOCK IS USED TO PROCESS THE ENGINE RPM FETCHED FROM THE OBD PORT OF THE CAR
+
+unsigned int process_engine_rpm(char *rpm_data_pointer)
+{
+    //char virtual_engine_rpm[] = "010C\r41 0C 00 00 \r\r>";
+    char engine_rpm[4];     // Vehicle speed data is returned by a 4 byte value
+    char *strtol_pointer;
+    char count;
+    char internal_count = 0;
+    
+    rpm_data_pointer += 11;
+    
+    for(count = 0; count < 5; count++)
+    {
+        if(*rpm_data_pointer == ' ') {        // Negate the spaces added in between
+            rpm_data_pointer++;
+            continue; }
+        else {
+            engine_rpm[internal_count] = *rpm_data_pointer++;
+            internal_count++; }
+    }
+    
+    DEBUG_UART.printf("\r\n%s", engine_rpm);
+    
+    rpm =  ((strtol(engine_rpm, &strtol_pointer, 16)) / 4);
+    
+    DEBUG_UART.printf("\r\nENGINE RPM = %ld", rpm);
+    return(rpm);
+}
+
+//*********************************************************************************************************************************************************************************
+
+// FUNCTION CALLED BY PARENT FUNCTION
+// THE FOLLOWING CODE BLOCK IS USED TO PROCESS THE BATTERY VOLTAGE FETCHED FROM THE OBD PORT OF THE CAR
+
+void process_battery_voltage(char *battery_voltage_pointer)
+{
+    char battery_voltage_data[4];   // One decimal point precision ( For ex : 12.5 )
+    char count;
+    battery_voltage_pointer += 5;   // ATRV<CR> counts to 5
+    for(count = 0; count < 4; count++)
+    {
+        battery_voltage_data[count] = *battery_voltage_pointer++;
+    }
+    car_battery_voltage = atof(battery_voltage_data);   // Converts the Battery Volatge from String to Float data type
+    //Misc_Packet_Data.Car_Battery_Voltage = (car_battery_voltage * 100);
+    DEBUG_UART.printf("\r\nCAR BATTERY VOLTAGE = %f",car_battery_voltage);
+}
+
+ 
+//*********************************************************************************************************************************************************************************
+
+/*
+_______________________________________________________________________________________________________________________
+
+NOTE :
+-----
+THE FOLLOWING CODE O DETERMINE THE DIAGNOSTIC TROUBLE CODE (DTC) IS BASED ON THE INTERPRETATION GIVEN IN WIKIPEDIA
+FOR THE  ISO 15765-2 PROTOCOL
+DIFFERENT INTERPRETATION METHODOLOGY IS GIVEN IN THE ELM327 DATASHEET FOR SAE PROTOCOL
+SO THESE THINGS ARE SUBJECTED TO MODIFICATION AND HAVE NOT BEEN CONFIRMED WITH THE REAL TIME DATA 
+_______________________________________________________________________________________________________________________
+
+*/
+
+// FUNCTION WILL BE CALLED ON REQUEST
+// THE FOLLOWING CODE BLOCK WILL FETCH THE DTC DATA FROM THE OBD PORT OF THE CAR AND SENDS THE SAME FOR PROCESSING
+
+void check_for_dtc()
+{
+    char virtual_dtc_buffer[] = "03\r43 00 85\r\r>";
+    
+    OBD_UART.printf(check_dtc_cmd);
+    wait(1);
+    while(!(OBD_UART_RX_Buffer[OBD_RxBuffer_End_Pos-1] == '>'));        // Waits here until the reception complete flag has been enabled
+    DEBUG_UART.printf("Reception Complete\r\n");
+    received_data_verification(OBD_UART_RX_Buffer, check_dtc_cmd, (strlen(check_dtc_cmd)-1));
+    
+    //process_dtc_data(virtual_dtc_buffer);
+    
+    
+    if(pass == 1) {
+        process_dtc_data(OBD_UART_RX_Buffer);
+        DEBUG_UART.printf("\r\VEHICLE DIAGNOSTIC TROUBLE CODE RECEIVED SUCCESSFULLY \r\n\r\n"); }
+    else
+        DEBUG_UART.printf("\r\nVEHICLE DIAGNOSTIC TROUBLE CODE DATA RECEPTION FAILED\r\n\r\n");
+    reception_complete = 0;     // Disabling the reception complete flag
+    OBD_RxBuffer_End_Pos = 0;   // Rx Buffer will be overwritten in the next data reception
+
+}
+
+//*********************************************************************************************************************************************************************************
+
+// FUNCTION WILL BE CALLED ON REQUEST
+// THE FOLLOWING CODE BLOCK WILL FETCH THE MIL DATA FROM THE OBD PORT OF THE CAR
+
+void check_for_MIL()
+{
+    
+    DEBUG_UART.printf("\r\n\r\nENTERED CHECK FOR MIL FUNCTION");
+    char count;
+    char virtual_mil_buffer[] = "0101\r41 01 82 04 60 00 \r\r";
+    
+    /*
+    OBD_UART.printf(check_mil_cmd);
+    
+    for(count = 0; count < strlen(check_mil_cmd); count++)
+        OBD_UART.putc(check_mil_cmd[count]);
+    wait(1);
+    while(!(OBD_UART_RX_Buffer[OBD_RxBuffer_End_Pos-1] == '>'));        // Waits here until the reception complete flag has been enabled
+    OBD_UART.printf("Reception Complete\r\n");
+    received_data_verification(OBD_UART_RX_Buffer, check_mil_cmd, (strlen(check_mil_cmd)-1));
+    */
+    
+    process_mil_data(virtual_mil_buffer);
+    
+    
+    if(pass == 1) {
+        process_mil_data(OBD_UART_RX_Buffer);
+        DEBUG_UART.printf("\r\nVEHICLE MIL DATA RECEIVED SUCCESSFULLY \r\n\r\n");}
+    else
+        DEBUG_UART.printf("\r\nVEHICLE MIL DATA RECEPTION FAILED\r\n\r\n");
+    reception_complete = 0;     // Disabling the reception complete flag
+    OBD_RxBuffer_End_Pos = 0;   // Rx Buffer will be overwritten in the next data reception
+    
+}
+
+
+//*********************************************************************************************************************************************************************************
+
+char fetch_vin_number()
+{
+    char count;
+    //char virtual_rx_vin_buffer[] = "3147 43\r314b \r58: 43 38 01 54 4D 42 \r1: 46 4B 4A 35 4A 32 43 \r2: 47 30 31 34 37 33 33 \r\r>"; 
+    char virtual_rx_vin_buffer[] = "0902 5\r014 \r0: 49 02 01 54 4D 42 \r1: 40 41 42 35 4A 32 43 \r2: 47 30 31 34 37 33 33 \r\r>"; 
+    //char virtual_rx_vin_buffer[] = "0902 5\r014 \r0: 49 02 01 54 4D 42 \r1: 46 4B 4A 35 4A 32 43 \r2: 47 30 31 34 37 33 33 \r\r>"; 
+    //char virtual_rx_vin_buffer[] = "0902 5\r014 \r0: 49 02 01 54 4D 42 \r1: 46 4B 4A 35 4A 32 43 \r2: 47 30 31 34 37 33 33 \r\r>"; 
+//    1GC1KXC82BF134775->31 47 43 31 4b 58 43 38 32 42 46 31 33 34 37 37 35
+//    1G1PC5SB0E7341780->31 47 31 50 43 35 53 42 30 45 37 33 34 31 37 38 30
+//    1G1RD6S56GU125328->31 47 31 52 44 36 53 35 36 47 55 31 32 35 33 32 38
+    char vin_number_cmd1[]           =   "0902 5\r";
+    OBD_UART.printf("VIN Reception Started24432\r\n");
+    
+    
+    char vin_buffer[100];
+    char *vin_data_pointer;
+    char internal_counter = 0;
+    char small_buffer[2];
+    long ascii_converted_data;
+    char *vin_conv_pointer;
+    char vin_number[17];
+    wait(1);
+    OBD_RxBuffer_End_Pos = 0;
+    //for(count = 0; count < strlen(vin_number_cmd1); count++)
+      //  OBD_UART.putc(vin_number_cmd[count]);
+    OBD_UART.putc(0x30);
+    OBD_UART.putc(0x39);
+    OBD_UART.putc(0x30);
+    OBD_UART.putc(0x32);
+    OBD_UART.putc(0x20);
+    OBD_UART.putc(0x35);
+    OBD_UART.putc(0x0D);
+    
+    OBD_UART.printf("VIN Reception Started   %d\r\n",strlen(virtual_rx_vin_buffer));
+    
+    vin_data_pointer = virtual_rx_vin_buffer;
+    vin_data_pointer += 23;
+    while(!(OBD_UART_RX_Buffer[OBD_RxBuffer_End_Pos-1] == '>'))        // Waits here until the reception complete flag has been enabled
+    {
+        if(OBD_RxBuffer_End_Pos >=6)
+            break;
+    }
+    for(count = 0; count < 86; count++)
+       OBD_UART.putc(OBD_UART_RX_Buffer[count]);
+    //OBD_UART.printf("VIN Reception Complete\r\n");
+    //return(1);
+    vin_data_pointer = OBD_UART_RX_Buffer;
+    vin_data_pointer += 23;
+    
+    int length;
+    for(count = 0; count < (strlen(virtual_rx_vin_buffer) - 1); count++)
+    {
+        if((*vin_data_pointer == '\r') | (*vin_data_pointer == ' ') | (*vin_data_pointer == '>'))
+        {
+            vin_data_pointer++;
+            continue;
+        }
+        else if(*(vin_data_pointer + 1) == ':')
+        {
+            vin_data_pointer += 2;
+            continue;
+        }
+        else
+        {
+            //printf("\r\ncount2 = %d", count); 
+            vin_buffer[internal_counter] = *vin_data_pointer;
+            internal_counter++;
+        }
+        vin_data_pointer++;
+    }
+    
+    length = strlen(vin_buffer);
+    DEBUG_UART.printf("\r\n VIN BUFFER LENGTH = %d", length);
+    
+    DEBUG_UART.printf("\r\n VIN NUMBER : %s", vin_buffer);
+    
+    internal_counter = 0;
+    
+    for(count = 0; count < strlen(vin_buffer); count+=2)
+    {
+        small_buffer[0] = vin_buffer[count];
+        small_buffer[1] = vin_buffer[count+1];
+        ascii_converted_data =  strtol(small_buffer, &vin_conv_pointer, 16);
+        vin_number[internal_counter] = ascii_converted_data;
+        //Misc_Packet_Data.VIN[internal_counter] = ascii_converted_data;
+        internal_counter++;
+    }
+    DEBUG_UART.printf("\r\n\r\nVEHICLE CHASSIS NUMBER : %s", vin_number);
+
+}
+
+//*********************************************************************************************************************************************************************************
+
+
+// FUNCTION WILL BE CALLED ON REQUEST
+// THE FOLLOWING CODE BLOCK FETCHES THE VEHICLE SPEED DATA FROM THE OBD PORT OF THE CAR AND SENDS THE SAME FOR PROCESSING
+
+float fetch_vehicle_speed()
+{
+    char virtual_rx_speed_buffer[] = "010D\r41 0D 4F \r\r>";     
+    char count;
+    //OBD_UART.printf(vehicle_speed_cmd);
+    
+    //for(count = 0; count < strlen(vehicle_speed_cmd); count++)
+       // OBD_UART.putc(vehicle_speed_cmd[count]);
+    //wait(1);
+   // while(!(OBD_UART_RX_Buffer[OBD_RxBuffer_End_Pos-1] == '>'));        // Waits here until the reception complete flag has been enabled
+   // DEBUG_UART.printf("Reception Complete\r\n");
+    //received_data_verification(OBD_UART_RX_Buffer, vehicle_speed_cmd, (strlen(vehicle_speed_cmd)-1));
+    
+    //
+    speed2=process_vehicle_speed(virtual_rx_speed_buffer);
+    
+    if(pass == 1) {
+       speed2= process_vehicle_speed(OBD_UART_RX_Buffer);
+        DEBUG_UART.printf("\r\nVEHICLE SPEED DATA RECEIVED SUCCESSFULLY \r\n\r\n"); }
+    else
+        DEBUG_UART.printf("\r\nVEHICLE SPEED DATA RECEPTION FAILED\r\n\r\n");
+    reception_complete = 0;     // Disabling the reception complete flag
+    OBD_RxBuffer_End_Pos = 0;   // Rx Buffer will be overwritten in the next data reception
+    return(speed2);
+    
+}  
+
+//*********************************************************************************************************************************************************************************
+
+// FUNCITON WILL BE CALLED  ON REQUEST
+// THE FOLLOWING CODE BLOCK FETCHES THE RPM DATA FROM THE OBD PORT OF THE CAR AND WILL SEND THE SAME FOR PROCESSING
+
+unsigned int fetch_engine_rpm()
+{
+    char count;
+    unsigned int RPM;
+    OBD_RxBuffer_End_Pos = 0;
+   
+    char virtual_engine_rpm[] = "010C\r41 0C 0E A2 \r\r>";
+    DEBUG_UART.printf("rpm Reception Start\r\n");
+//    for(count = 0; count < strlen(engine_rpm_cmd); count ++)
+//        OBD_UART.putc(engine_rpm_cmd[count]);
+//    wait(1);
+//    while(!(OBD_UART_RX_Buffer[OBD_RxBuffer_End_Pos-1] == '>'));        // Waits here until the reception complete flag has been enabled
+//    OBD_UART.printf("Reception Complete\r\n");
+//    received_data_verification(OBD_UART_RX_Buffer, engine_rpm_cmd, (strlen(engine_rpm_cmd)-1));
+//    
+    
+    //process_engine_rpm(virtual_engine_rpm);
+    if(pass == 1) {
+        RPM = process_engine_rpm(virtual_engine_rpm);
+        DEBUG_UART.printf("\r\nVEHICLE SPEED DATA RECEIVED SUCCESSFULLY \r\n\r\n"); }
+    else
+        DEBUG_UART.printf("\r\nVEHICLE SPEED DATA RECEPTION FAILED\r\n\r\n");
+    reception_complete = 0;     // Disabling the reception complete flag
+    OBD_RxBuffer_End_Pos = 0;   // Rx Buffer will be overwritten in the next data reception
+    return(RPM);
+}
+ 
+//*********************************************************************************************************************************************************************************
+
+// FUNCTION WILL BE CALLED ON REQUEST
+// THE FOLLOWING CODE BLOCK FETCHED THE BATTERY VOLTAGE DATA FROM THE OBD PORT AND PASSES THE SAME DATA FOR PROCESSING
+
+void fetch_battery_voltage()
+{
+    char count;
+    //OBD_UART.printf(battery_voltage_cmd);
+    OBD_UART.printf("Battery Voltage\r\n");
+    for(count = 0; count < strlen(battery_voltage_cmd); count++){
+        OBD_UART.putc(battery_voltage_cmd[count]);
+        OBD_UART.printf("0x%2x ",battery_voltage_cmd[count]);
+    }
+    wait(1);
+    
+    while(!(OBD_UART_RX_Buffer[OBD_RxBuffer_End_Pos-1] == '>'));        // Waits here until the reception complete flag has been enabled
+    DEBUG_UART.printf("Reception Complete\r\n");
+    received_data_verification(OBD_UART_RX_Buffer, battery_voltage_cmd, (strlen(battery_voltage_cmd)-1));
+    
+
+    if(pass == 1) {
+        DEBUG_UART.printf("\r\nOBD READ BATTERY VOLTAGE SUCCESSFUL");
+        process_battery_voltage(OBD_UART_RX_Buffer); }
+    else
+        DEBUG_UART.printf("\r\nOBD READ BATTERY VOLTAGE FAILED");
+    reception_complete = 0;     // Disabling the reception complete flag
+    OBD_RxBuffer_End_Pos = 0;   // Rx Buffer will be overwritten in the next data reception
+}
+  
+    
+//*********************************************************************************************************************************************************************************
+
+// FUNCTION WILL BE CALLED ON REQUEST
+// TYHE FOLLOWING CODE BLOXK INITIALIZES THE OBD INTERFACE
+// IT IS MANDATORY TO CALL THIS FUNCTION BEFORE USING ANY OF THE OTHER FUNCTIONS INCLUDED IN THIS PARTICULAR LIBRARY
+
+void initialize_obd()
+{
+    char count;
+    char data[3];
+    char *data_pointer;  
+
+    data_pointer = data;
+    
+    //OBD_UART.baud(9600);
+//    OBD_UART.attach(&OBD_onDataRx);
+    
+    DEBUG_UART.printf("Reception Started\r\n");
+    
+ //--------------------------------------------------------------------------------------------------------------------------     
+    //for(Misc_Count=0; Misc_Count < 5; Misc_Count++) {
+//        OBD_UART.putc(battery_voltage_cmd[Misc_Count]);
+//    }
+    OBD_UART.printf(obd_reset_cmd);
+
+    wait(1);
+    
+  //~sbn~   while(!(OBD_UART_RX_Buffer[OBD_RxBuffer_End_Pos-1] == '>'));        // Waits here until the reception complete flag has been enabled
+    DEBUG_UART.printf("Reception Complete\r\n");
+    received_data_verification(OBD_UART_RX_Buffer, obd_reset_cmd, (strlen(obd_reset_cmd)-1));
+
+    if(pass == 1)
+        DEBUG_UART.printf("\r\nOBD RESET SUCCESSFUL \r\n\r\n");
+    else
+        DEBUG_UART.printf("\r\nOBD RESET FAILED \r\n\r\n");
+   // fetch_battery_voltage();        
+    reception_complete = 0;     // Disabling the reception complete flag
+    OBD_RxBuffer_End_Pos = 0;   // Rx Buffer will be overwritten in the next data reception
+    
+//--------------------------------------------------------------------------------------------------------------------------  
+
+    //OBD_UART.printf(allow_long_cmd);
+    for(count = 0; count < strlen(allow_long_cmd); count++)
+        OBD_UART.putc(allow_long_cmd[count]);
+    wait(1);
+//~sbn~  while(!(OBD_UART_RX_Buffer[OBD_RxBuffer_End_Pos-1] == '>'));        // Waits here until the reception complete flag has been enabled
+    DEBUG_UART.printf("Reception Complete\r\n");
+    received_data_verification(OBD_UART_RX_Buffer, allow_long_cmd, (strlen(allow_long_cmd)-1));
+
+    if(pass == 1)
+        DEBUG_UART.printf("\r\nLONG DATA RECEPTION ENABLED SUCCESSFULLY \r\n\r\n");
+    else
+        DEBUG_UART.printf("\r\nLONG DATA RECEPTION ENABLING FAILED\r\n\r\n");
+    reception_complete = 0;     // Disabling the reception complete flag
+    OBD_RxBuffer_End_Pos = 0;   // Rx Buffer will be overwritten in the next data reception
+    
+}
+ /*********************************************************************************************************************************************************************************/
\ No newline at end of file