FIELD OF INVENTION

The present invention relates to a car ignition system based on android application controlled biometric sensor. The present invention also relates to a biometric based ignition system of vehicle and an Android application to access the finger print sensor because all human being have unique, immutable fingerprints which consists of a sequence of ridges and furrows/valleys on the exterior of the finger. The present invention also relates to a biometric based ignition system of vehicle wherein the individuality of a fingerprint can be resolute by the pattern of ridges and furrows as well as the finer points and biometric substantiation increases the system safety to a vast extent. The present invention also relates to a biometric based ignition system of vehicle wherein the enrolment of fingerprint image or removing any previous fingerprint data becomes user friendly for this android application and the vehicle engine will be ignited only if fingerprint image is registered in fingerprint sensor.

BACKGROUND OF THE PRIOR ART
In present era Anti Theft devices of vehicles are prime concern in automobile field due to the rising number of vehicle thefts. Biometric systems have overtime served as robust security mechanisms in various domains. Fingerprints are the oldest and most widely used form of biometric identification. It can be taken up to use as a figure of security in already existing systems, such as automobile. Remote locking devices or Key lock system is not fully secured. Remote locking devices of vehicle use radio wave to encrypt data. This wave can be recorded and decrypted to unlock the car. Duplicate key can be made easily. So these two locking systems are failed to secure vehicle properly. Another contention of vehicle is handling its key. Keys need to be carried and misplacing keys can drop us in unpleasant situation. This invention focuses on the use of fingerprints for vehicle ignition, opposite to the conventional method of using keys. The prototype system could be divided into the following: firstly an android application which will be used for enrolling or deleting user’s fingerprint image and secondly, a biometric sensor through which engine of vehicle will be ignited. The hybrid app is built using Html5, CSS3 and jQuery and then is wrapped inside a native Android Wrapper. The app will be helping with the enrolment, deletion and viewing user profiles registered already. The fingerprint sensor enables fingerprints of valid users of the vehicle to be enrolled into the sensor. To ignite the vehicle, fingerprint image of user has to be matched against the fingerprints in the database while users with no match in the database are prevented from igniting the vehicle. When user wishes to stop the engine, he will place unregistered finger on the sensor.

The documents US7138904 describes a keyless system for operating and accessing a vehicle such as an automobile, truck, minivan, bus, airplane, train, boat, etc. Preferably, the user's fingerprint is his or her “right of passage” into the vehicle. The system includes fingerprint triggered access to the physical inside space of a vehicle and along with other commands, preferably voice activated and/or card/card reader, control the vehicle's various systems. The system is designed to perform optimally in less than perfect environmental conditions and is preferably provided with its own source of energy. The system also includes a controller and interface in communication with a fingerprint sensor.
Another document US9381890 discloses a system includes a processor configured to detect push-to-start (PTS) button engagement. The processor is also configured to scan a finger positioned on a vehicle fingerprint scanner for a fingerprint. The processor is further configured to verify that the fingerprint corresponds to an authorized driver and engage a vehicle ignition when the fingerprint corresponds to an authorized driver.
Other documents US6633090 illustrates a starting system for an engine of an automotive vehicle having an ignition system includes a fingerprint sensor (26) that generates a fingerprint signal. A memory has a plurality of authorized fingerprint signals stored therein. A switch (28) is used to generate a start signal. A controller is coupled to the ignition system (20), the fingerprint sensor (26), the memory (18), and switch (28). The controller compares the fingerprint signal with the authorized fingerprint signal stored in the memory and enables the ignition system in response to the start signal and the fingerprint signal being substantially equal to an authorized fingerprint signal.

SUMMARY OF INVENTION

The present invention relates to a car ignition system based on android application controlled biometric sensor. The present invention also relates to a biometric based ignition system of vehicle and an Android application to access the finger print sensor because all human being have unique, immutable fingerprints which consists of a sequence of ridges and furrows/valleys on the exterior of the finger. The present invention also relates to a biometric based ignition system of vehicle wherein the individuality of a fingerprint can be resolute by the pattern of ridges and furrows as well as the finer points and biometric substantiation increases the system safety to a vast extent. The present invention also relates to a biometric based ignition system of vehicle wherein the enrolment of fingerprint image or removing any previous fingerprint data becomes user friendly for this android application and the vehicle engine will be ignited only if fingerprint image is registered in fingerprint sensor.

DETAIL DESCRIPTION OF THE INVNETION WITH THE ACCOMPANYING DRAWINGS

For the purpose of facilitating an understanding of the invention, there is illustrated in the preferred embodiment thereof, from an inspection of which, when considered in connection with the following description, the invention, its construction and operation, and many of its advantages should be readily understood and appreciated.
The principal object of the invention is to provide the car ignition system based on android application controlled biometric sensor.

The other object of the invention is to provide the car ignition system based on android application controlled biometric sensor which comprising: a biometric sensor for capturing identifying biometric data of a person to be registered; a data entry android app for receiving entered data; a microcontroller ATmega 328 coupled to the biometric sensor and to the data entry device for receiving captured identifying biometric data and entered data; a registration database coupled to the microcontroller ATmega 328 for storing captured records representing the identifying biometric data and the entered data for the person to be verified, wherein the identifying biometric data of the person to be verified is related to the entered data in the database registration record biometric device thereof; whereby the person to be verified and allowed to ignite the car.

The other object of the invention is to provide the car ignition system based on android application controlled biometric sensor wherein the vehicle engine can be turning off by impression of any unregistered finger placing it on fingerprint sensor.
The other object of the invention is to provide the car ignition system based on android application controlled biometric sensor wherein there is a sequence of ridges and furrows/valleys on the exterior of the finger.
The other object of the invention is to provide the car ignition system based on android application controlled biometric sensor wherein there is a sequence of ridges and furrows/valleys on the exterior of the finger. Management System using Mobile Application.
The other object of the invention is to provide the car ignition system based on android application controlled biometric sensor wherein the individuality of a fingerprint can be resolute by the pattern of ridges and furrows as well as the finer points and biometric substantiation increases the system safety to a vast extent.
The other object of the invention is to provide the car ignition system based on android application controlled biometric sensor wherein the enrolment of fingerprint image or removing any previous fingerprint data becomes user friendly for this android application and the vehicle engine will be ignited only if fingerprint image is registered in fingerprint sensor.

The other object of the invention is to provide the car ignition system based on android application controlled biometric sensor which provides a protected and hassle free way to start or stop vehicle engine.
As per another aspect, the disclosure includes communications layer for receiving and transmitting voting results which applies the communication protocols by which data is transmitted and received data is interpreted, and further provides security for the data communicated; and wherein the data is preferably data encrypted when stored and when communicated, both for security in transmission and against alteration and/or corruption, whether accidental or intentional.

In summarizing the arrangements described and/or claimed herein, a selection of concepts and/or elements and/or steps that are described in the detailed description herein may be made or simplified. Any summary is not intended to identify key features, elements and/or steps, or essential features, elements and/or steps, relating to the claimed subject matter, and so are not intended to be limiting and should not be construed to be limiting of or defining of the scope and breadth of the claimed subject matter.

Fig 1 illustrates the essential parts and working of a battery Key Ignition system with Key;

Fig 2 illustrates Flowchart of fingerprint registration through Android App “FP Access”;

Fig 3 illustrates the Flowchart of ignition system through biometric system;

Fig 4 illustrates the Simulation when digital high is applied at base of BJT;

Fig 5 illustrates the Simulation when digital low is applied at base of BJT;

Fig 6(a) illustrates Schematic diagram of proposed system;

Fig 6(b) illustrates the PROTOTYPE PICTURE OF THE IGNITION SYSTEM;

Fig 7(a) illustrates the availability of the android app “FP Access” in Google Play Store;

Fig 7(b) illustrates the login page of the android app “FP Access” to access biometric device;

Fig 7(c) illustrates the registered database of users through app;

Fig 7(d) illustrates the enrolment section of user through the app;

Fig 7(e) illustrates the pairing device option through the app;

Fig 7(f) illustrates transmission of data to Biometric Device
The described android app controlled biometric based car ignition system and methods include the registration of persons seeking to drive the car by capturing their biometric data and the generation of an electronic registration database to provide control to others. All registered finger impression data is preferably encrypted for security and prevention of alteration.

The proposed system is based on ignition of vehicle engine through biometric verification. Fig 1 describes the current method of car ignition system. An ignition system generates a spark or heats an electrode to a high temperature to ignite a fuel-air mixture in spark ignition internal combustion engines, oil-fired and gas-fired boilers, rocket engines, etc. The widest application for spark ignition internal combustion engines is in petrol (gasoline) road vehicles such as cars and motorcycles. We know that in case of Internal Combustion (IC) engines, combustion of air and fuel takes place inside the engine cylinder and the products of combustion expand to produce reciprocating motion of the piston. When the ignition switch is turned on, current flows from the battery to the ignition coil. Current flows through the primary winding of the ignition coil where one end is connected to the contact breaker. A cam which is connected directly to the camshaft opens and closes the contact breaker points according to the number of engine cylinders. A condenser absorbs the back EMF from the magnetic field, thereby increasing the life of contact points by reducing burning of the points. When the cam lobe pushes CB switch, the contact breaker points opens, which causes the current from primary circuit to break. Due to break in current, an EMF is induced in the secondary winding having a greater number of turns than primary, which increases the battery’s 12 Volts to 22,000 Volts. The high voltage produced by the secondary winding is then transferred to the distributor. A rotor inside the distributor rotates according to the ignition timing. When the rotor comes exactly in front of the distributor point, the voltage jumps due to the air gap from the rotor to the point. High Voltage is then transferred from the distributor to the spark plug terminal via a high-tension cable. A voltage difference is generated between the central electrode and ground electrode. The voltage continues to transfer through the central electrode which is sealed using insulator. When the voltage exceeds the dielectric strength of the gases between these electrodes, the gases are ionized. Due to ionization, gas becomes a conductor and allows the current to flow through the gap and spark is finally produced.
Fig 2 illustrates user enrolment process into the biometric device using android app “FP Access”. Using this app, fingerprint data of unwanted user can be deleted also. Fig 3 illustrates the process of car ignition system through biometric sensor. Fig4 and Fig5 illustrate simulated results of our investigation. Fig 6(a) & Fig 6(b) describes the schematic diagram of our ignition system and prototype of the system simultaneously. Fig 7(a), Fig 7(b), Fig 7(c), Fig 7(d) and Fig 7(e) illustrates various function of our android app “FP Access”.

The android app “FP Access” which is designed by Mr. Tunir Saha and Mr. Aman Ghosh (two of the applicants of this Patent filing), is available on Google Play Store. User has to install this app in their mobile. Through this android app, user can register fingerprint data into biometric sensor. Whenever it is needed, user can also delete unwanted registered data. To register or unregister any user, all the queries asked by the android app is shown through a Liquid Crystal Display (LCD). The android app “FP Access” is interfaced with biometric sensor through a Bluetooth Module.

For the purpose of ignite the car engine; user has to be appeared for finger print test through Biometric Sensor. If finger print of user is identified, car engine will be ignited. If finger print is not identified, car engine will not be turned on. After turning on the engine, when it is needed to turn off, an unregistered finger must be placed on biometric sensor.

BASIC COMPONENTS AND ANDROID APPLICATION USED IN THIS PROTOTYPE:

i) ARDUINO UNO:
The disclosed Arduino Uno is a microcontroller board based on the ATmega328 (datasheet). It has 14 digital input/output pins (of which 6 can be used as PWM outputs), 6 analog inputs, a 16 MHz crystal oscillator, a USB connection, a power jack, an ICSP header, and a reset button. It contains everything needed to support the microcontroller; simply connect it to a computer with a USB cable or power it with a AC-to-DC adapter or battery to get started. The logic circuitry which interface with Modified Arduino code of fingerprint authentication for which thumb impression of voter will be automatically deleted after cast a vote.

ii) FINGERPRINT SENSOR MODULE – R305:
The Fingerprint processing includes two parts: fingerprint enrolment and fingerprint matching (the matching can be 1:1 or 1:N ). When enrolling, user needs to enter the finger two times. The system will process the two time finger images, generate a template of the finger based on processing results and store the template. When matching, user enters the finger through optical sensor and system will generate a template of the finger and compare it with templates of the finger library. For 1:1 matching, system will compare the live finger with specific template designated in the Module; for 1:N matching, or searching, system will search the whole finger library for the matching finger. In both circumstances, system will return the matching result, success or failure.

iii) HC-05 Bluetooth Module
The HC-05 is a bluetooth module which can add two-way (full-duplex) wireless functionality. We can use this module to communicate between two microcontrollers like Arduino or communicate with any device with Bluetooth functionality like a Phone or Laptop. The module communicates with the help of USART at 9600 baud rate hence it is easy to interface with any microcontroller that supports USART. We can also configure the default values of the module by using the command mode.

iv) CL 100 TRANSISTOR
The disclosed CL100 transistor is a general purpose, medium power NPN transistor. It is mostly used as switch in common emitter configuration. The transistor terminals require a fixed DC voltage to operate in the desired region of its characteristic curves. This is known as the biasing. For switching applications, SL100/Cl100 is biased in such a way that it remains fully on if there is a signal at its base. In the absence of base signal, it gets turned off completely. The emitter leg of SL100/Cl100 is indicated by a protruding edge in the transistor case. The base is nearest to the emitter while collector lies at other extreme of the casing.

v) 10K Potentiometer
A potentiometer is a manually adjustable variable resistor with 3 terminals. Two terminals are connected to both ends of a resistive element, and the third terminal connects to a sliding contact, called a wiper, moving over the resistive element. The position of the wiper determines the output voltage of the potentiometer.

vi) RELAY – 6V:
The Relay is an electromagnetic device which is used to isolate two circuits electrically and connect them magnetically. They are very useful devices and allow one circuit to switch another one while they are completely separate. They are often used to interface an electronic circuit (working at a low voltage) to an electrical circuit which works at very high voltage. Their job can be compared to that of a transistor working as a switch but with a difference that relays cannot handle high frequency inputs, unlike transistors. A relay consists of an electromagnetic coil which, when given proper amount of current and voltage, changes its state from NC to NO.

vii) Push to ON Push to OFF Switch:
A push switch (button) is a momentary or non-latching switch which causes a temporary change in the state of an electrical circuit only while the switch is physically actuated. An automatic mechanism (i.e. a spring) returns the switch to its default position immediately afterwards, restoring the initial circuit condition.

viii) JUMPER WIRE
A jump wire (also known as jumper, jumper wire, jumper cable, DuPont wire, or DuPont cable – named for one manufacturer of them) is an electrical wire, or group of them in a cable, with a connector or pin at each end (or sometimes without them – simply "tinned"), which is normally used to interconnect the components of a breadboard or other prototype or test circuit, internally or with other equipment or components, without soldering.

ix) LIQUID CRYSTAL DISPLAY
A liquid crystal display or LCD draws its definition from its name itself. It is a combination of two states of matter, the solid and the liquid. LCD uses a liquid crystal to produce a visible image. Liquid crystal displays are super-thin technology display screens that are generally used in laptop computer screens, TVs, cell phones and portable video games. LCD’s technologies allow displays to be much thinner when compared to a cathode ray tube (CRT) technology. Liquid crystal display is composed of several layers which include two polarized panel filters and electrodes.

x) RECHARGEABLE BATTERY

A rechargeable battery, storage battery, or secondary cell, (or archaically accumulator) is a type of electrical battery which can be charged, discharged into a load, and recharged many times, as opposed to a disposable or primary battery, which is supplied fully charged and discarded after use. It is composed of one or more electrochemical cells. The term "accumulator" is used as it accumulates and stores energy through a reversible electrochemical reaction. Rechargeable batteries are produced in many different shapes and sizes, ranging from button cells to megawatt systems connected to stabilize an electrical distribution network.

xi) FP ACCESS: ANDROID APP
Android app, “FP Access” which is designed by which is designed by Mr. Tunir Saha and Mr. Aman Ghosh (two of the applicants of this Patent filing), is available on Google Play Store. User has to install this app in their mobile. Through this android app user can register fingerprint data into biometric sensor. Whenever it is needed, user can also delete unwanted registered data.

CIRCUIT DESIGN DESCRIPTIONS:
In order to implement a flawless car engine ignition system with more security, the ignition process is fabricated with biometric sensor. The operation of our new system is explained step by step.
In our research work we replace ignition key with biometric sensor. An Arduino Uno is coupled with biometric sensor. Here, Arduino Uno will be operated in two modes through a switch. Codes of two modes are written in multi tab of Arduino IDE. In one mode, when switch is ‘OFF’ and ‘zero’ voltage is applied at digital pin 9 of Arduino Uno, an Android mobile App “FP Access” is communicated with Biometric Sensor through a Bluetooth module. The Android mobile App “FP Access” is developed by Mr. Tunir Saha and Mr. Aman Ghosh (two of the applicants of this Patent filing). In another mode when switch is ‘ON’ and high voltage is applied at digital pin 9 of Arduino Uno, biometric sensor will be used to ignite car engine of vehicle. We developed an android application through which user’s fingerprint data will be registered as well as removed from the sensor module memory. We have built the hybrid app using HTML5, CSS3, and jQuery and wrapped the code inside a native android web browser wrapper. The reason for using hybrid methodology was to develop it in less time as native app code would have taken more of time. In the future updates we will convert the hybrid app to native. When we connect our mobile phone (containing the android app) to the to the biometric sensor through Bluetooth module, the app would be giving 3 options - Enroll User - The user clicks this option in the app, and a screen pops up to enter user details. After entering user details, when you click on register, a request is made to the Arduino Module having the HC05 Bluetooth module with the ID number of the fingerprint that is to be scanned. We are storing the last recorded IDs in the app for now. After the enrolment procedure is complete, the Arduino sends an acknowledgement using the HC05, which is then updated in the app and the user now can be seen in the app as a registered user in the app. Delete User - The user clicks this option in the app, and a screen pops up to select the user from the list of the existing enrolled user list. After selecting the enrolled user, when you click on delete, a request is made to the Arduino Module having the HC05 Bluetooth module with the ID number of the fingerprint that is to be deleted. The Arduino sends an acknowledgement using the HC05 after deleting it from the memory of the R305 Module, which is then updated in the app and the user now is removed and cannot be seen in the list of enrolled users. View User Data - An option to see the list of enrolled users.
When the unit is operational without the app, i.e. when the user is only using the sensor unit to start or off engine of vehicle, the user is supposed to press a button (placed a tactile switch) to disable the android application mode and continue with the normal start/off mode. If user wants to start engine, a finger whose image is already registered in sensor unit must be placed on Biometric Sensor. Biometric technologies by definition recognize individuals based on behavioural and physical characteristics such as fingerprints, facial features, an iris pattern, and hand geometry, a vein pattern of the palm or finger, and signature dynamics. To switch off the engine, any unregistered finger must be placed on biometric sensor. Biometric sensor is coupled with Arduino Uno with the Finger verification code uploaded in it; if fingerprint image matches, then the digital pin D6 of Arduino Uno will be set high. Digital pin D6 of Arduino is connected to the base of a BJT for switching purpose. Here we used two transistor switching model. SiC power bipolar junction transistor (BJT) has been developed in recent years due to its unique properties such as low on resistance, normally off nature, positive temperature coefficient of the on state-resistance, negative temperature coefficient of the current gain, and fast switching speed .We have simulated the switching section for high and low digital value at base of BJT by Proteus. The simulation result shows no output available when digital low value applied at base of BJT, and 11.99volt is available if digital high value is applied at base of BJT. Collector terminal of 2nd BJT of switching section is connected to common terminal of a 12volt Relay. When digital pin D6 of Arduino Uno will be high, relay will be energized and 12volt battery will be connected to Normally Open terminal of Relay. A ballast resistor is placed in between Normally Open terminal of Relay and ignition coil of ignition system. A ballast resistor is an electronic component that is often used to regulate the current in a circuit. Thus, when fingerprint image of user is matched, current flows from the battery to the ignition coil and following other electro- mechanical process, spark is finally produced. If user wants to stop engine, any unregistered finger must be placed on biometric sensor. Due to the mismatch of fingerprint data digital pin D6 of Arduino will be low as separate code is written for mismatch of fingerprint within the fingerprint verification code. If pin D6 of Arduino UNO is low, Relay will be de-energized and 12volt battery will be disconnected from ballast resistor. Thus, the current conduction will be stopped and engine will be off.

Arduino Modularized Source Code for the various processes:

Main Code Block :

#include
#include
#include
SoftwareSerial mySerial(12, 13);
SoftwareSerial bt(8,7);
const int BJT=6;
Adafruit_Fingerprint finger = Adafruit_Fingerprint(&mySerial);
#define deviceSerialNumber 11111 // unique device identifier
#define modePin 9 // D9 for detecting bluetoothMode or normal mode
#define btBPS 9600 // Bluetooth Serial Connection Baud Rate
#define serialBPS 115200 // Normal Serial Connection Baud Rate
#define fBPS 57600 // Fingerprint Serial Connection Baud Rate
String action=""; // incoming action from bluetooth
int fid=-1; // fingerprint ID for storing
int bid=-1; // incoming device ID for verification
LiquidCrystal lcd(11,10,2,3,4,5);

void setup()
{
pinMode(BJT,OUTPUT);
lcd.begin(16, 2);
pinMode(modePin, INPUT_PULLUP);
Serial.begin(serialBPS);
finger.begin(fBPS);
Serial.println("Adafruit Fingerprint sensor enrollment");
if (finger.verifyPassword()) {
Serial.println("Found fingerprint sensor!");
} else {
Serial.println("Did not find fingerprint sensor :(");
while (1) { delay(1); }
}
mySerial.end();
}
void loop()
{
digitalWrite(BJT,LOW);
bt.begin(btBPS);
if(digitalRead(modePin)==0 && bt.available()>0){
String incomingData = bt.readString();
bt.end();
readBluetoothData(incomingData);
delay(10); // do not remove
if(bid!=deviceSerialNumber){
Serial.println("Device ID Mismatch");
} else if(action=="delete" && bid==deviceSerialNumber){
Serial.print("Id to delete is-"); Serial.println(fid);
uint8_t status_code = deleteFingerprint((uint8_t)fid);
mySerial.end();
Serial.println(status_code);
btStatusEmit(status_code,(uint8_t)0);
} else if(action=="add" && bid==deviceSerialNumber){
Serial.print("Id to Add is-"); Serial.println(fid);
uint8_t status_code = getFingerprintEnroll((uint8_t)fid);
mySerial.end();
Serial.println(status_code);
btStatusEmit(status_code,(uint8_t)0);
}
}
if(digitalRead(modePin)==1){
normalMode();
}
}
void normalMode(){
bt.end();
Serial.println("Waiting for valid finger...");
lcd.setCursor(1,0);
lcd.print("Waiting for");
lcd.setCursor(0,1);
lcd.print("valid finger...");
delay(500);
lcd.clear();
uint8_t status_code = getFingerprintIDez();
mySerial.end();
if(status_code!=255){
write_here();
}
delay(50);
}
void btStatusEmit(uint8_t status_code, uint8_t code){
bt.begin(btBPS);
if(status_code==code){
bt.print("success");
} else {
bt.print("fail");
}
bt.end();
}

Enroll FP Module:

uint8_t getFingerprintEnroll(uint8_t id) {
finger.begin(fBPS);
uint8_t p = -1;
Serial.print("Waiting for valid finger to enroll as #");
lcd.setCursor(1,0);
lcd.print("Press valid");
lcd.setCursor(0,1);
lcd.print("finger to enroll");
delay(2000);
lcd.clear();
Serial.println(id);
while (p != FINGERPRINT_OK) {
p = finger.getImage();
switch (p) {
case FINGERPRINT_OK:
Serial.println("Image taken");
lcd.setCursor(1,0);
lcd.print("Image taken");
lcd.clear();
delay(1000);
break;
case FINGERPRINT_NOFINGER:
Serial.println(".");
break;
case FINGERPRINT_PACKETRECIEVEERR:
Serial.println("Communication error1");
break;
case FINGERPRINT_IMAGEFAIL:
Serial.println("Imaging error");
break;
default:
Serial.println("Unknown error");
break;
}
}
// OK success!

p = finger.image2Tz(1);
switch (p) {
case FINGERPRINT_OK:
Serial.println("Image converted");
break;
case FINGERPRINT_IMAGEMESS:
Serial.println("Image too messy");
return p;
case FINGERPRINT_PACKETRECIEVEERR:
Serial.println("Communication error2");
return p;
case FINGERPRINT_FEATUREFAIL:
Serial.println("Could not find fingerprint features");
return p;
case FINGERPRINT_INVALIDIMAGE:
Serial.println("Could not find fingerprint features");
return p;
default:
Serial.println("Unknown error");
return p;
}
Serial.println("Remove finger");
delay(2000);
p = 0;
while (p != FINGERPRINT_NOFINGER) {
p = finger.getImage();
}
Serial.print("ID ");
Serial.println(id);
p = -1;
Serial.println("Place same finger again");
lcd.setCursor(1,0);
lcd.print("Place same ");
lcd.setCursor(0,1);
lcd.print("finger again");
delay(1000);
lcd.clear();

while (p != FINGERPRINT_OK) {
p = finger.getImage();
switch (p) {
case FINGERPRINT_OK:
Serial.println("Image taken");
break;
case FINGERPRINT_NOFINGER:
Serial.print(".");
break;
case FINGERPRINT_PACKETRECIEVEERR:
Serial.println("Communication error3");
break;
case FINGERPRINT_IMAGEFAIL:
Serial.println("Imaging error");
break;
default:
Serial.println("Unknown error");
break;
}
}
// OK success!

p = finger.image2Tz(2);
switch (p) {
case FINGERPRINT_OK:
Serial.println("Image converted");
break;
case FINGERPRINT_IMAGEMESS:
Serial.println("Image too messy");
return p;
case FINGERPRINT_PACKETRECIEVEERR:
Serial.println("Communication error4");
return p;
case FINGERPRINT_FEATUREFAIL:
Serial.println("Could not find fingerprint features");
return p;
case FINGERPRINT_INVALIDIMAGE:
Serial.println("Could not find fingerprint features");
return p;
default:
Serial.println("Unknown error");
return p;
}

// OK converted!
Serial.print("Creating model for #"); Serial.println(id);

p = finger.createModel();
if (p == FINGERPRINT_OK) {
Serial.println("Prints matched!");
} else if (p == FINGERPRINT_PACKETRECIEVEERR) {
Serial.println("Communication error5");
return p;
} else if (p == FINGERPRINT_ENROLLMISMATCH) {
Serial.println("Fingerprints did not match");
return p;
} else {
Serial.println("Unknown error");
return p;
}
Serial.print("ID ");
Serial.println(id);
p = finger.storeModel(id);
if (p == FINGERPRINT_OK) {
Serial.println("Stored!");
lcd.setCursor(1,0);
lcd.print("Remove ");
lcd.setCursor(0,1);
lcd.print("Finger");
delay(1000);
lcd.clear();
lcd.setCursor(1,0);
lcd.print("Stored");
delay(1000);
lcd.clear();

return p;
} else if (p == FINGERPRINT_PACKETRECIEVEERR) {
Serial.println("Communication error6");
return p;
} else if (p == FINGERPRINT_BADLOCATION) {
Serial.println("Could not store in that location");
return p;
} else if (p == FINGERPRINT_FLASHERR) {
Serial.println("Error writing to flash");
return p;
} else {
Serial.println("Unknown error");
return p;
}
}

Delete FP Module:

uint8_t deleteFingerprint(uint8_t id) {
finger.begin(fBPS);
uint8_t p = -1;
p = finger.deleteModel(id);
if (p == FINGERPRINT_OK) {
Serial.println("Deleted!");
return p;
} else if (p == FINGERPRINT_PACKETRECIEVEERR) {
Serial.println("Communication error");
return p;
} else if (p == FINGERPRINT_BADLOCATION) {
Serial.println("Could not delete in that location");
return p;
} else if (p == FINGERPRINT_FLASHERR) {
Serial.println("Error writing to flash");
return p;
} else {
Serial.print("Unknown error: 0x");
Serial.println(p, HEX);
return p;
}
}

Read FP Module:

int getFingerprintIDez() {
finger.begin(fBPS);
finger.getTemplateCount();
Serial.print("Sensor contains ");
Serial.print(finger.templateCount);
Serial.println(" templates");
uint8_t p = finger.getImage();
if (p != FINGERPRINT_OK) return -1;
p = finger.image2Tz();
if (p != FINGERPRINT_OK) return -1;
p = finger.fingerFastSearch();
if (p != FINGERPRINT_OK);
{
digitalWrite(BJT,LOW);
return -1;
}
else
{
digitalWrite(BJT,HIGH);
}

// found a match!
Serial.print("Found ID #"); Serial.print(finger.fingerID);
Serial.print(" with confidence of "); Serial.println(finger.confidence);
return finger.fingerID;
}

Read BT Module:

void readBluetoothData(String a){
int lmt=0;
String arr[4]={"","","",""};
if(a!="x"){
for(int i=0;i0?arr[2].toInt():-1;
bid=arr[1].toInt()>9999?arr[1].toInt():-1;
}
}

Work (For Debugging Purpose):

void write_here(){
lcd.setCursor(1,0);
lcd.print("Hello You Can");
lcd.setCursor(0,1);
lcd.print("Start...");
delay(2000);
lcd.clear();
}

ANDROID APP CODE

The MainActivity.java file:

package skubotics.in.fpaccessor;

import android.Manifest;
import android.annotation.TargetApi;
import android.app.AlertDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.database.Cursor;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.net.Uri;
import android.net.wifi.WifiManager;
import android.os.Build;
import android.os.Handler;
import android.provider.ContactsContract;
import android.provider.Settings;
import android.support.annotation.Nullable;
import android.support.v4.app.ActivityCompat;
import android.support.v4.content.ContextCompat;
import android.support.v4.widget.SwipeRefreshLayout;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.webkit.WebChromeClient;
import android.webkit.WebSettings;
import android.webkit.WebStorage;
import android.webkit.WebView;
import android.webkit.WebViewClient;
import android.widget.Toast;

import java.io.File;
import java.util.HashMap;
import java.util.Map;

public class MainActivity extends AppCompatActivity {
boolean isForceUpdate = true;
public static String EXTRA_USERID = "UserId";
Controller controller= new Controller();
private WebView webview, hidwebview;
SwipeRefreshLayout SwipeRefreshLayout;
WifiManager wifimanager;
private static final String TEL_PREFIX = "tel:";
String url="1";

@Nullable
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);
deleteCache(MainActivity.this);

webview = findViewById(R.id.webView);
hidwebview = findViewById(R.id.hidweb);
webview.clearCache(true);
webview.clearHistory();
hidwebview.getSettings().setJavaScriptEnabled(true);
SwipeRefreshLayout = (SwipeRefreshLayout) this.findViewById(R.id.swipeContainer);
webview.setWebViewClient(new WebViewClient());
webview.getSettings().setJavaScriptEnabled(true);
webview.getSettings().setAllowFileAccess(true);
webview.getSettings().setAppCacheEnabled(true);
webview.getSettings().setDomStorageEnabled(true);
webview.getSettings().setDatabaseEnabled(true);
String databasePath = this.getApplicationContext().getDir("database", Context.MODE_PRIVATE).getPath();
webview.getSettings().setDatabasePath(databasePath);
webview.setWebChromeClient(new WebChromeClient() {
public void onExceededDatabaseQuota(String url, String databaseIdentifier, long currentQuota, long estimatedSize, long totalUsedQuota, WebStorage.QuotaUpdater quotaUpdater) {
quotaUpdater.updateQuota(5 * 1024 * 1024);
}
});
webview.getSettings().setCacheMode(WebSettings.LOAD_CACHE_ELSE_NETWORK);
webview.setOverScrollMode(WebView.OVER_SCROLL_NEVER);
//Check if network or internet is available
ConnectivityManager ConnectionManager = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo networkInfo = ConnectionManager.getActiveNetworkInfo();
ConnectivityManager connManager = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo mWifi = connManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI);

//mProgress = ProgressDialog.show(this, "Fetching your Data...", "Please wait...");
//hidwebview.setVisibility(View.VISIBLE);
Intent i1 = getIntent();
url = i1.getStringExtra("url");
hidwebview.loadUrl(url);

webview.loadUrl("https://skubotics.in/FPAccess/app/index.html");

webview.setWebViewClient(new CustomWebViewClient() {

@Override
public void onPageFinished(WebView view, String url) {
//Remove the progress dialog after the website loaded completely
//hidwebview.setVisibility(View.GONE);
SwipeRefreshLayout.setRefreshing(false);
}

public void onReceivedError(WebView webView, int errorCode, String description, final String failingUrl) {
try {
webView.stopLoading();
} catch (Exception e) {
}
if (webView.canGoBack()) {
webView.goBack();
}
//webview.loadUrl("file:///android_asset/error.html");
super.onReceivedError(webView, errorCode, description, failingUrl);
final String Url = failingUrl;
SwipeRefreshLayout.setOnRefreshListener(
new SwipeRefreshLayout.OnRefreshListener() {
@Override
public void onRefresh() {
webview.loadUrl(Url);
}
}
);
}
});

SwipeRefreshLayout.setOnRefreshListener(
new SwipeRefreshLayout.OnRefreshListener() {
@Override
public void onRefresh() {
webview.loadUrl(webview.getUrl());
}
}
);
}
boolean doubleBackToExitPressedOnce = false;

@Override
public void onBackPressed() {
if (webview.canGoBack()) {
webview.goBack();
} else {
super.onBackPressed();
}
}
private class CustomWebViewClient extends WebViewClient {
@Override
public boolean shouldOverrideUrlLoading(WebView wv, String url) {
if (url.startsWith(TEL_PREFIX)) {
Intent intent = new Intent(Intent.ACTION_DIAL);
intent.setData(Uri.parse(url));
startActivity(intent);
return true;
}
if (url != null && url.startsWith("settings://addwifi")) {
startActivity(new Intent(Settings.ACTION_WIFI_SETTINGS));
return true;
}
if ((url != null && url.contains("delete-"))||(url != null && url.contains("add-"))) {
String TAG = "URL";
Log.i(TAG, url);
String[] words=url.split("app/");
Intent i = new Intent(MainActivity.this, DeviceList.class);
i.putExtra(EXTRA_USERID, words[1]);
startActivity(i);
return true;
}
return false;
}
}
public static void deleteCache(Context context) {
try {
File dir = context.getCacheDir();
deleteDir(dir);
} catch (Exception e) {
e.printStackTrace();
}
}
public static boolean deleteDir(File dir) {
if (dir != null && dir.isDirectory()) {
String[] children = dir.list();
for (int i = 0; i < children.length; i++) {
boolean success = deleteDir(new File(dir, children[i]));
if (!success) {
return false;
}
}
return dir.delete();
} else if (dir != null && dir.isFile()) {
return dir.delete();
} else {
return false;
}
}
public void checkWifi() {
AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setTitle("Alert");
builder.setCancelable(true);
builder.setMessage("Connect to your device hotspot");//TODO put real question
builder.setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int id) {
startActivity(new Intent(Settings.ACTION_WIFI_SETTINGS));
dialog.cancel();
}
});
builder.setNegativeButton(android.R.string.cancel, new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int id) {
dialog.cancel();
}
});
builder.show();
// Show an expanation to the user *asynchronously* -- don't block
// this thread waiting for the user's response! After the user
// sees the explanation, try again to request the permission.
}
}
The DeviceList.java file:
package skubotics.in.fpaccessor;

import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.content.Intent;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.AdapterView;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.ListView;
import android.widget.TextView;
import android.widget.Toast;

import java.util.ArrayList;
import java.util.Set;

import static skubotics.in.fpaccessor.MainActivity.EXTRA_USERID;

public class DeviceList extends AppCompatActivity {

Button btnPaired;
ListView devicelist;

private BluetoothAdapter myBluetooth = null;
private Set pairedDevices;
public static String EXTRA_ADDRESS = "device_address";
public static String EXTRA_USERID = "UserId";

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_device_list);

btnPaired = (Button) findViewById(R.id.button);
devicelist = (ListView) findViewById(R.id.listView);

myBluetooth = BluetoothAdapter.getDefaultAdapter();
if ( myBluetooth==null ) {
Toast.makeText(getApplicationContext(), "Bluetooth device not available", Toast.LENGTH_LONG).show();
finish();
} else if ( !myBluetooth.isEnabled() ) {
Intent turnBTon = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
startActivityForResult(turnBTon, 1);
}
btnPaired.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
devicelist.setVisibility(View.VISIBLE);
pairedDevicesList();
}
});
}
private void pairedDevicesList () {
pairedDevices = myBluetooth.getBondedDevices();
ArrayList list = new ArrayList();

if ( pairedDevices.size() > 0 ) {
for ( BluetoothDevice bt : pairedDevices ) {
list.add(bt.getName().toString() + "\n" + bt.getAddress().toString());
}
} else {
Toast.makeText(getApplicationContext(), "No Paired Bluetooth Devices Found.", Toast.LENGTH_LONG).show();
}
final ArrayAdapter adapter = new ArrayAdapter(this, android.R.layout.simple_list_item_1, list);
devicelist.setAdapter(adapter);
devicelist.setOnItemClickListener(myListClickListener);
}
private AdapterView.OnItemClickListener myListClickListener = new AdapterView.OnItemClickListener() {
@Override
public void onItemClick(AdapterView parent, View view, int position, long id) {
String info = ((TextView) view).getText().toString();
String address = info.substring(info.length()-17);
Intent i1 = getIntent();
String usedID = i1.getStringExtra("UserId");
Intent intent = new Intent(DeviceList.this, Controller.class);
intent.putExtra(EXTRA_ADDRESS, address);
intent.putExtra(EXTRA_USERID, usedID);
startActivity(intent);
}
};
}
The Controller.java file:

package skubotics.in.fpaccessor;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.UUID;
import android.app.Activity;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothSocket;
import android.content.Intent;
import android.os.Bundle;
import android.os.Handler;
import android.view.View;
import android.view.View.OnClickListener;
import android.webkit.WebView;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
import android.widget.Toast;

public class Controller extends Activity {
Button btnOn, btnOff;
TextView txtArduino;
Handler bluetoothIn;

final int handlerState = 0; //used to identify handler message
private BluetoothAdapter btAdapter = null;
private BluetoothSocket btSocket = null;
private StringBuilder recDataString = new StringBuilder();

private ConnectedThread mConnectedThread;
private WebView hidwebview;

// SPP UUID service - this should work for most devices
private static final UUID BTMODULEUUID = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB");

// String for MAC address
private static String address;
private static String userid;
Intent intent;

@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);

setContentView(R.layout.activity_control);
intent =getIntent();
//Link the buttons and textViews to respective views
btnOn = (Button) findViewById(R.id.button2);
userid = intent.getStringExtra("UserId");
hidwebview = findViewById(R.id.hidweb);
bluetoothIn = new Handler() {
public void handleMessage(android.os.Message msg) {
if (msg.what == handlerState) { //if message is what we want
String readMessage = (String) msg.obj;
recDataString.append(readMessage);

if(readMessage.contains("ccess")){
Intent intent = new Intent(Controller.this, MainActivity.class);
String[] separated = userid.split("-");
if(separated.length>3) {
intent.putExtra("url", "https://skubotics.in/FPAccess/api/removeDriverGet.php?did=" + separated[3]);
}
startActivity(intent);
//String url="https://skubotics.in/FPAccess/api/removeDriverGet.php?did="+separated[3];
// hidwebview.loadUrl(url);
// finish();
}
recDataString.delete(0, recDataString.length()); //clear all string data
// strIncom =" ";

}
}
};

btAdapter = BluetoothAdapter.getDefaultAdapter(); // get Bluetooth adapter
checkBTState();

btnOn.setOnClickListener(new OnClickListener() {
public void onClick(View v) {
mConnectedThread.write(userid); // Send "1" via Bluetooth
Toast.makeText(getBaseContext(), "Process Started", Toast.LENGTH_SHORT).show();
}
});
}
private BluetoothSocket createBluetoothSocket(BluetoothDevice device) throws IOException {
return device.createRfcommSocketToServiceRecord(BTMODULEUUID);
//creates secure outgoing connecetion with BT device using UUID
}
@Override
public void onResume() {
super.onResume();

//Get MAC address from DeviceListActivity via intent

//Get the MAC address from the DeviceListActivty via EXTRA
address = intent.getStringExtra(DeviceList.EXTRA_ADDRESS);
userid = intent.getStringExtra("UserId");

//create device and set the MAC address
BluetoothDevice device = btAdapter.getRemoteDevice(address);

try {
btSocket = createBluetoothSocket(device);
} catch (IOException e) {
Toast.makeText(getBaseContext(), "Socket creation failed", Toast.LENGTH_LONG).show();
}
// Establish the Bluetooth socket connection.
try
{
btSocket.connect();
} catch (IOException e) {
try
{
btSocket.close();
} catch (IOException e2)
{
//insert code to deal with this
}
}
mConnectedThread = new ConnectedThread(btSocket);
mConnectedThread.start();

//I send a character when resuming.beginning transmission to check device is connected
//If it is not an exception will be thrown in the write method and finish() will be called
//mConnectedThread.write("x");
userid = intent.getStringExtra("UserId");
}
@Override
public void onPause()
{
super.onPause();
try
{
//Don't leave Bluetooth sockets open when leaving activity
btSocket.close();
} catch (IOException e2) {
//insert code to deal with this
}
}
//Checks that the Android device Bluetooth is available and prompts to be turned on if off
private void checkBTState() {

if(btAdapter==null) {
Toast.makeText(getBaseContext(), "Device does not support bluetooth", Toast.LENGTH_LONG).show();
} else {
if (btAdapter.isEnabled()) {
} else {
Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
startActivityForResult(enableBtIntent, 1);
}
}
}
//create new class for connect thread
private class ConnectedThread extends Thread {
private final InputStream mmInStream;
private final OutputStream mmOutStream;

//creation of the connect thread
public ConnectedThread(BluetoothSocket socket) {
InputStream tmpIn = null;
OutputStream tmpOut = null;

try {
//Create I/O streams for connection
tmpIn = socket.getInputStream();
tmpOut = socket.getOutputStream();
} catch (IOException e) { }

mmInStream = tmpIn;
mmOutStream = tmpOut;
}
public void run() {
byte[] buffer = new byte[256];
int bytes;
// Keep looping to listen for received messages
while (true) {
try {
bytes = mmInStream.read(buffer); //read bytes from input buffer
String readMessage = new String(buffer, 0, bytes);
// Send the obtained bytes to the UI Activity via handler
bluetoothIn.obtainMessage(handlerState, bytes, -1, readMessage).sendToTarget();
} catch (IOException e) {
break;
}
}
}
//write method
public void write(String input) {
byte[] msgBuffer = input.getBytes(); //converts entered String into bytes
try {
mmOutStream.write(msgBuffer); //write bytes over BT connection via outstream
} catch (IOException e) {
//if you cannot write, close the application
Toast.makeText(getBaseContext(), "Connection Failure", Toast.LENGTH_LONG).show();
finish();
}
}
}
}

BASIC CIRCUIT COMPONENTS:
i) ARDUINO UNO
ii) FINGERPRINT SENSOR MODULE – R305
iii) HC-05 Bluetooth Module:
iv) CL 100 TRANSISTOR:
v) 10K Potentiometer:
vi) RELAY – 6V
vii) Push to ON Push to OFF Switch
viii) Jumper Wire
ix) Liquid Crystal Display
x) Rechargeable Battery
xi) FP ACCESS: Android App
CIRCUIT DESIGN DESCRIPTIONS:
FIG: 1 Essential parts and working of a battery Key Ignition system with Key
FIG: 2 Flowchart of fingerprint registration through Android App “FP Access”
FIG: 3 Flowchart of ignition system through biometric system
FIG: 4 Simulation when digital high is applied at base of BJT
FIG: 5 Simulation when digital low is applied at base of BJT
FIG: 6(a) Diagram of proposed system
FIG: 6(b) PROTOTYPE PICTURE OF THE IGNITION SYSTEM
FIG: 7(a) Availability of the android app “FP Access” in Google Play Store
FIG: 7(b) Login page of the android app “FP Access” to access biometric device
FIG: 7(c) Registered database of users through app
FIG: 7(d) Enrolment section of user through the app
FIG: 7(e) Transmission of data to Biometric Device
FIG: 7(f) Pairing device option through the app

Advantages :
1) Android app controlled biometric based ignition system.
2) Registration of finger impression becomes user friendly through android app.
3) Unwanted registered finger impression data can be deleted through android app.
4) Security of car is enhanced.
5) No need to carry ignition key.

While exemplary embodiments are described above, it is not intended that these embodiments describe all possible forms of the invention. Rather, the words used in the specification are words of description rather than limitation, and it is understood that various changes may be made without departing from the spirit and scope of the invention. Additionally, the features of various implementing embodiments may be combined to form further embodiments of the invention.

WE CLAIM:

1) A car ignition system based on android application controlled biometric sensor which comprising:
i) a biometric sensor for capturing identifying biometric data of a person to be registered; a data entry android app for receiving entered data;
ii) a microcontroller ATmega 328 coupled to the biometric sensor and to the data entry device for receiving captured identifying biometric data and entered data;
iii) a registration database coupled to the microcontroller ATmega 328 for storing captured records representing the identifying biometric data and the entered data for the person to be verified, wherein the identifying biometric data of the person to be verified is related to the entered data in the database registration record biometric device thereof; whereby the person to be verified and allowed to ignite the car.
2) The car ignition system based on android application controlled biometric sensor wherein there is a sequence of ridges and furrows/valleys on the exterior of the finger.
3) The car ignition system based on android application controlled biometric sensor wherein there is a sequence of ridges and furrows/valleys on the exterior of the finger. Management System using Mobile Application.
4) The car ignition system based on android application controlled biometric sensor wherein the vehicle engine can be turning off by impression of any unregistered finger placing it on fingerprint sensor.
5) The car ignition system based on android application controlled biometric sensor wherein the individuality of a fingerprint can be resolute by the pattern of ridges and furrows as well as the finer points and biometric substantiation increases the system safety to a vast extent.
6) The car ignition system based on android application controlled biometric sensor wherein the enrolment of fingerprint image or removing any previous fingerprint data becomes user friendly for this android application and the vehicle engine will be ignited only if fingerprint image is registered in fingerprint sensor.
7) The car ignition system based on android application controlled biometric sensor which provides a protected and hassle free way to start or stop vehicle engine.